all.hpp

Go to the documentation of this file.

/*************************************************************************
 * Copyright (C) 2018-2019 Blue Brain Project
 *
 * This file is part of NMODL distributed under the terms of the GNU
 * Lesser General Public License. See top-level LICENSE file for details.
 *************************************************************************/

///
/// THIS FILE IS GENERATED AT BUILD TIME AND SHALL NOT BE EDITED.
///

#pragma once

/**
 * \dir
 * \brief Auto generated AST Implementations
 *
 * \file
 * \brief Auto generated AST classes declaration
 */

#include "ast/ast.hpp"

#ifndef NMODL_AST_NODE_HPP
#define NMODL_AST_NODE_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Base class for all AST node
 *
 * Base class for all nodes in the AST. This can replace ast::Ast in
 * the next refactoring.
 *
 */
class Node : public Ast {

public:
  /// \name Ctor & dtor
  /// \{

  virtual ~Node() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::Node
   * \return true as object is of type ast::Node
   */
  bool is_node() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  virtual Node *clone() const override { return new Node(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::NODE
   *
   * \sa Ast::get_node_type_name
   */
  virtual AstNodeType get_node_type() const noexcept override {
    return AstNodeType::NODE;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Node"
   *
   * \sa Ast::get_node_name
   */
  virtual std::string get_node_type_name() const noexcept override {
    return "Node";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  virtual std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Node>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  virtual std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Node>(shared_from_this());
  }

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  virtual void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  virtual void accept(visitor::Visitor &v) override;

  /// \}
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_NODE_HPP
#ifndef NMODL_AST_STATEMENT_HPP
#define NMODL_AST_STATEMENT_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class Statement : public Node {

public:
  /// \name Ctor & dtor
  /// \{

  virtual ~Statement() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::Statement
   * \return true as object is of type ast::Statement
   */
  bool is_statement() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  virtual Statement *clone() const override { return new Statement(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::STATEMENT
   *
   * \sa Ast::get_node_type_name
   */
  virtual AstNodeType get_node_type() const noexcept override {
    return AstNodeType::STATEMENT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Statement"
   *
   * \sa Ast::get_node_name
   */
  virtual std::string get_node_type_name() const noexcept override {
    return "Statement";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  virtual std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Statement>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  virtual std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Statement>(shared_from_this());
  }

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  virtual void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  virtual void accept(visitor::Visitor &v) override;

  /// \}
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_STATEMENT_HPP
#ifndef NMODL_AST_EXPRESSION_HPP
#define NMODL_AST_EXPRESSION_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Base class for all expressions in the NMODL
 *
 * Base class for all expression types. This is one of the top level node
 * in the AST representing higher level expression constructs. %Expressions
 * can be a variable itself or complex binary expressions.
 *
 * \sa ast::Statement
 *
 */
class Expression : public Node {

public:
  /// \name Ctor & dtor
  /// \{

  virtual ~Expression() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::Expression
   * \return true as object is of type ast::Expression
   */
  bool is_expression() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  virtual Expression *clone() const override { return new Expression(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::EXPRESSION
   *
   * \sa Ast::get_node_type_name
   */
  virtual AstNodeType get_node_type() const noexcept override {
    return AstNodeType::EXPRESSION;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Expression"
   *
   * \sa Ast::get_node_name
   */
  virtual std::string get_node_type_name() const noexcept override {
    return "Expression";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  virtual std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Expression>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  virtual std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Expression>(shared_from_this());
  }

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  virtual void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  virtual void accept(visitor::Visitor &v) override;

  /// \}
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_EXPRESSION_HPP
#ifndef NMODL_AST_BLOCK_HPP
#define NMODL_AST_BLOCK_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Base class for all block scoped nodes
 *
 * NMODL has different local and global block scoped nodes like
 * ast::NeuronBlock, ast::ParamBlock, ast::IfStatement etc. Ast::Block
 * is base class and defines common interface for these nodes.
 *
 */
class Block : public Expression {

public:
  /// \name Ctor & dtor
  /// \{

  virtual ~Block() = default;

  /// \}

  /// \name Not implemented
  /// \{

  virtual const ArgumentVector &get_parameters() const {
    throw std::runtime_error("get_parameters not implemented");
  }

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::Block
   * \return true as object is of type ast::Block
   */
  bool is_block() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  virtual Block *clone() const override { return new Block(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::BLOCK
   *
   * \sa Ast::get_node_type_name
   */
  virtual AstNodeType get_node_type() const noexcept override {
    return AstNodeType::BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Block"
   *
   * \sa Ast::get_node_name
   */
  virtual std::string get_node_type_name() const noexcept override {
    return "Block";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  virtual std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Block>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  virtual std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Block>(shared_from_this());
  }

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  virtual void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  virtual void accept(visitor::Visitor &v) override;

  /// \}
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_BLOCK_HPP
#ifndef NMODL_AST_IDENTIFIER_HPP
#define NMODL_AST_IDENTIFIER_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Base class for all identifiers
 *
 * Base class for all variable types like ast::Name, ast::PrimeName and
 * ast::Argument.
 *
 * \sa ast::Number
 *
 */
class Identifier : public Expression {

public:
  /// \name Ctor & dtor
  /// \{

  virtual ~Identifier() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::Identifier
   * \return true as object is of type ast::Identifier
   */
  bool is_identifier() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  virtual Identifier *clone() const override { return new Identifier(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::IDENTIFIER
   *
   * \sa Ast::get_node_type_name
   */
  virtual AstNodeType get_node_type() const noexcept override {
    return AstNodeType::IDENTIFIER;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Identifier"
   *
   * \sa Ast::get_node_name
   */
  virtual std::string get_node_type_name() const noexcept override {
    return "Identifier";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  virtual std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Identifier>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  virtual std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Identifier>(shared_from_this());
  }

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  virtual void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  virtual void accept(visitor::Visitor &v) override;

  /// \}
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_IDENTIFIER_HPP
#ifndef NMODL_AST_NUMBER_HPP
#define NMODL_AST_NUMBER_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Base class for all numbers
 *
 * Base class for all number types like ast::Integer, ast::Float and
 * ast::Double.
 *
 */
class Number : public Expression {

public:
  /// \name Ctor & dtor
  /// \{

  virtual ~Number() = default;

  /// \}

  /// \name Not implemented
  /// \{

  virtual double to_double() {
    throw std::runtime_error("to_double not implemented");
  }

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::Number
   * \return true as object is of type ast::Number
   */
  bool is_number() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  virtual Number *clone() const override { return new Number(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::NUMBER
   *
   * \sa Ast::get_node_type_name
   */
  virtual AstNodeType get_node_type() const noexcept override {
    return AstNodeType::NUMBER;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Number"
   *
   * \sa Ast::get_node_name
   */
  virtual std::string get_node_type_name() const noexcept override {
    return "Number";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  virtual std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Number>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  virtual std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Number>(shared_from_this());
  }

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  virtual void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  virtual void accept(visitor::Visitor &v) override;

  /// \}
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_NUMBER_HPP
#ifndef NMODL_AST_STRING_HPP
#define NMODL_AST_STRING_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a string
 *
 * All statements encapsulating text block are stored in the AST as ast::String.
 * For example, nodes like ast::LineComment and ast::Verbatim block use
 * ast::String::value to store the underlying text:
 *
 * \code{.mod}
 *     COMMENT
 *       This text is stored as String
 *     ENDCOMMENT
 *
 *     VERBATIM
 *         int *x;
 *         *x = ...
 *     ENDVERBATIM
 * \endcode
 *
 */
class String : public Expression {
private:
  /// Value of string
  std::string value;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit String(const std::string &value);
  String(const String &obj);

  String() = default;

  virtual ~String() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::String
   * \return true as object is of type ast::String
   */
  bool is_string() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  String *clone() const override { return new String(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::STRING
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::STRING;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "String"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override { return "String"; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<String>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const String>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref String.value
   */
  const std::string &get_value() const noexcept { return value; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Set new value to the current ast node
   * \sa String::eval
   */
  void set(std::string _value) { value = _value; }

  /**
   * \brief Setter for member variable \ref String.value
   */
  void set_value(std::string value);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

  /**
   * \brief Return value of the ast node
   *
   * Base data type nodes like ast::Inetegr, ast::Double can be evaluated
   * to their literal values. This method is used to access underlying
   * literal value.
   *
   * \sa String::set
   */
  std::string eval() const { return value; }

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_STRING_HPP
#ifndef NMODL_AST_INTEGER_HPP
#define NMODL_AST_INTEGER_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents an integer variable
 *
 * Non floating value in the mod file is parsed as an integer. For example,
 * in the below code, integer literals like `0` and `11` are stored as
 * ast::Integer in the AST :
 *
 * \code{.mod}
 *     FROM i=0 TO N {
 *         tau = X[i] + 11
 *     }
 * \endcode
 *
 * \sa ast::Float ast::Double
 *
 */
class Integer : public Number {
private:
  /// Value of integer
  int value;
  /// if integer is a macro then it's name
  std::shared_ptr<Name> macro;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit Integer(int value, Name *macro);
  explicit Integer(int value, const std::shared_ptr<Name> &macro);
  Integer(const Integer &obj);

  Integer() = default;

  virtual ~Integer() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::Integer
   * \return true as object is of type ast::Integer
   */
  bool is_integer() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  Integer *clone() const override { return new Integer(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::INTEGER
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::INTEGER;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Integer"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override { return "Integer"; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Integer>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Integer>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref Integer.value
   */
  int get_value() const noexcept { return value; }

  /**
   * \brief Getter for member variable \ref Integer.macro
   */
  const std::shared_ptr<Name> &get_macro() const noexcept { return macro; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Set new value to the current ast node
   * \sa Integer::eval
   */
  void set(int _value) { value = _value; }

  /**
   * \brief Setter for member variable \ref Integer.value
   */
  void set_value(int value);

  /**
   * \brief Setter for member variable \ref Integer.macro (rvalue reference)
   */
  void set_macro(std::shared_ptr<Name> &&macro);

  /**
   * \brief Setter for member variable \ref Integer.macro
   */
  void set_macro(const std::shared_ptr<Name> &macro);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

  /**
   * \brief Negate the value of current ast node
   *
   * Parser parse `-x` in two parts : `x` and then `-`. Once second token
   * `-` is encountered, the corresponding value of ast node needs to be
   * multiplied by `-1` for ast::Number node types.
   */
  void negate() override { value = -value; }

  /**
   * \brief Return value of the current ast node as double
   */
  double to_double() override { return value; }

  /**
   * \brief Return value of the ast node
   *
   * Base data type nodes like ast::Inetegr, ast::Double can be evaluated
   * to their literal values. This method is used to access underlying
   * literal value.
   *
   * \sa Integer::set
   */
  int eval() const { return value; }

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_INTEGER_HPP
#ifndef NMODL_AST_FLOAT_HPP
#define NMODL_AST_FLOAT_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a float variable
 *
 * Single precision float value in the mod file can be represented by
 * ast::Float.
 *
 * \note Currently every float variable in the NMODL is stored as ast::Double
 * and hence this type is note used. This will be changed soon for variables
 * like ast::ParamAssign.
 *
 * \sa ast::Integer ast::Double
 *
 */
class Float : public Number {
private:
  /// Value of float
  float value;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit Float(float value);
  Float(const Float &obj);

  virtual ~Float() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::Float
   * \return true as object is of type ast::Float
   */
  bool is_float() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  Float *clone() const override { return new Float(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::FLOAT
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::FLOAT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Float"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override { return "Float"; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Float>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Float>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref Float.value
   */
  float get_value() const noexcept { return value; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Set new value to the current ast node
   * \sa Float::eval
   */
  void set(float _value) { value = _value; }

  /**
   * \brief Setter for member variable \ref Float.value
   */
  void set_value(float value);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

  /**
   * \brief Negate the value of current ast node
   *
   * Parser parse `-x` in two parts : `x` and then `-`. Once second token
   * `-` is encountered, the corresponding value of ast node needs to be
   * multiplied by `-1` for ast::Number node types.
   */
  void negate() override { value = -value; }

  /**
   * \brief Return value of the current ast node as double
   */
  double to_double() override { return value; }

  /**
   * \brief Return value of the ast node
   *
   * Base data type nodes like ast::Inetegr, ast::Double can be evaluated
   * to their literal values. This method is used to access underlying
   * literal value.
   *
   * \sa Float::set
   */
  float eval() const { return value; }

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_FLOAT_HPP
#ifndef NMODL_AST_DOUBLE_HPP
#define NMODL_AST_DOUBLE_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a double variable
 *
 * %Double precision float value in the mod file is represented by ast::Double.
 * For example, float literals like `0.1` in the mod file are parsed as double
 * and stored using ast::Double::value :
 *
 * \code{.mod}
 *     PROCEDURE foo() {
 *       LOCAL x
 *       x = 0.1 + tau
 *     }
 * \endcode
 *
 * Note that the variables are not classified ast integer or float in the AST.
 * The decision about variable types is done by code generation backends.
 *
 * \sa ast::Integer ast::Float
 *
 */
class Double : public Number {
private:
  /// Value of double
  double value;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit Double(double value);
  Double(const Double &obj);

  Double() = default;

  virtual ~Double() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::Double
   * \return true as object is of type ast::Double
   */
  bool is_double() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  Double *clone() const override { return new Double(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::DOUBLE
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::DOUBLE;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Double"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override { return "Double"; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Double>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Double>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref Double.value
   */
  double get_value() const noexcept { return value; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Set new value to the current ast node
   * \sa Double::eval
   */
  void set(double _value) { value = _value; }

  /**
   * \brief Setter for member variable \ref Double.value
   */
  void set_value(double value);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

  /**
   * \brief Negate the value of current ast node
   *
   * Parser parse `-x` in two parts : `x` and then `-`. Once second token
   * `-` is encountered, the corresponding value of ast node needs to be
   * multiplied by `-1` for ast::Number node types.
   */
  void negate() override { value = -value; }

  /**
   * \brief Return value of the current ast node as double
   */
  double to_double() override { return value; }

  /**
   * \brief Return value of the ast node
   *
   * Base data type nodes like ast::Inetegr, ast::Double can be evaluated
   * to their literal values. This method is used to access underlying
   * literal value.
   *
   * \sa Double::set
   */
  double eval() const { return value; }

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_DOUBLE_HPP
#ifndef NMODL_AST_BOOLEAN_HPP
#define NMODL_AST_BOOLEAN_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a boolean variable
 *
 * %Boolean values in the mod file can be represented by ast::Boolean.
 *
 * \note Currently this type is used as only flag in some of the AST nodes.
 * Similar to ast::Float, this type was introduced for data type specific code
 * generation support in the future.
 *
 */
class Boolean : public Number {
private:
  /// Value of boolean
  int value;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit Boolean(int value);
  Boolean(const Boolean &obj);

  virtual ~Boolean() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::Boolean
   * \return true as object is of type ast::Boolean
   */
  bool is_boolean() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  Boolean *clone() const override { return new Boolean(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::BOOLEAN
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::BOOLEAN;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Boolean"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override { return "Boolean"; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Boolean>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Boolean>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref Boolean.value
   */
  int get_value() const noexcept { return value; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Set new value to the current ast node
   * \sa Boolean::eval
   */
  void set(bool _value) { value = _value; }

  /**
   * \brief Setter for member variable \ref Boolean.value
   */
  void set_value(int value);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

  /**
   * \brief Negate the value of current ast node
   *
   * Parser parse `-x` in two parts : `x` and then `-`. Once second token
   * `-` is encountered, the corresponding value of ast node needs to be
   * multiplied by `-1` for ast::Number node types.
   */
  void negate() override { value = !value; }

  /**
   * \brief Return value of the current ast node as double
   */
  double to_double() override { return value; }

  /**
   * \brief Return value of the ast node
   *
   * Base data type nodes like ast::Inetegr, ast::Double can be evaluated
   * to their literal values. This method is used to access underlying
   * literal value.
   *
   * \sa Boolean::set
   */
  bool eval() const { return value; }

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_BOOLEAN_HPP
#ifndef NMODL_AST_NAME_HPP
#define NMODL_AST_NAME_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a name
 *
 * Whenever lexer encounters string variable, it returns a ast::Name
 * type. So, along with ast::Integer, ast::Double ast::String and
 * ast::PrimeName, ast::Name is one of the fundamental type in the AST. Many
 * other variable types (e.g. ast::GlobalVar, ast::RangeVar) have underlying
 * value stored as ast::Name.
 *
 * \note This node should be able to use std::string as value type instead of
 * ast::String
 *
 */
class Name : public Identifier {
private:
  /// Value of name
  std::shared_ptr<String> value;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit Name(String *value);
  explicit Name(const std::shared_ptr<String> &value);
  Name(const Name &obj);

  Name() = default;

  virtual ~Name() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::Name
   * \return true as object is of type ast::Name
   */
  bool is_name() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  Name *clone() const override { return new Name(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::NAME
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::NAME;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Name"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override { return "Name"; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Name>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Name>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return name of the node
   *
   * Some ast nodes have a member marked designated as node name. For example,
   * in case of this ast::String has value designated as a
   * node name.
   *
   * @return name of the node as std::string
   *
   * \sa Ast::get_node_type_name
   */
  std::string get_node_name() const override;

  /**
   * \brief Getter for member variable \ref Name.value
   */
  const std::shared_ptr<String> &get_value() const noexcept { return value; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set name for the current ast node
   *
   * Some ast nodes have a member marked designated as node name (e.g. nodes
   * derived from ast::Identifier). This method is used to set new name for
   * those nodes. This useful for passes like nmodl::visitor::RenameVisitor.
   *
   * \sa Ast::get_node_type_name Ast::get_node_name
   */
  void set_name(const std::string &name) override;

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref Name.value (rvalue reference)
   */
  void set_value(std::shared_ptr<String> &&value);

  /**
   * \brief Setter for member variable \ref Name.value
   */
  void set_value(const std::shared_ptr<String> &value);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_NAME_HPP
#ifndef NMODL_AST_PRIME_NAME_HPP
#define NMODL_AST_PRIME_NAME_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a prime variable (for ODE)
 *
 * In case of ODE specification, all state variables appearing on LHS
 * with \` as suffix are parsed by lexer as ast::PrimeName. For example,
 * in below NMODL construct, m\` is stored as ast::PrimeName with `m` as a
 * ast::PrimeName::value and `1` as an ast::PrimeName::order.
 *
 * \code
 *     DERIVATIVE states {
 *       m` = m + h
 *     }
 * \endcode
 *
 */
class PrimeName : public Identifier {
private:
  /// Name of prime variable
  std::shared_ptr<String> value;
  /// order of ODE
  std::shared_ptr<Integer> order;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit PrimeName(String *value, Integer *order);
  explicit PrimeName(const std::shared_ptr<String> &value,
                     const std::shared_ptr<Integer> &order);
  PrimeName(const PrimeName &obj);

  PrimeName() = default;

  virtual ~PrimeName() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::PrimeName
   * \return true as object is of type ast::PrimeName
   */
  bool is_prime_name() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  PrimeName *clone() const override { return new PrimeName(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::PRIME_NAME
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::PRIME_NAME;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "PrimeName"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "PrimeName";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<PrimeName>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const PrimeName>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return name of the node
   *
   * Some ast nodes have a member marked designated as node name. For example,
   * in case of this ast::String has value designated as a
   * node name.
   *
   * @return name of the node as std::string
   *
   * \sa Ast::get_node_type_name
   */
  std::string get_node_name() const override;

  /**
   * \brief Getter for member variable \ref PrimeName.value
   */
  const std::shared_ptr<String> &get_value() const noexcept { return value; }

  /**
   * \brief Getter for member variable \ref PrimeName.order
   */
  const std::shared_ptr<Integer> &get_order() const noexcept { return order; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref PrimeName.value (rvalue reference)
   */
  void set_value(std::shared_ptr<String> &&value);

  /**
   * \brief Setter for member variable \ref PrimeName.value
   */
  void set_value(const std::shared_ptr<String> &value);

  /**
   * \brief Setter for member variable \ref PrimeName.order (rvalue reference)
   */
  void set_order(std::shared_ptr<Integer> &&order);

  /**
   * \brief Setter for member variable \ref PrimeName.order
   */
  void set_order(const std::shared_ptr<Integer> &order);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_PRIME_NAME_HPP
#ifndef NMODL_AST_INDEXED_NAME_HPP
#define NMODL_AST_INDEXED_NAME_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents specific element of an array variable
 *
 * If variable is declared as an array or when array element is accessed,
 * it is stored in the ast as ast::IndexedName. For example, in below NMODL,
 * construct `m[4]` is stored as ast::IndexedName with `m` as
 * ast::IndexedName::name and `4` as ast::IndexedName::legth.
 *
 * \code
 *     STATE {
 *       m[4]
 *     }
 * \endcode
 *
 */
class IndexedName : public Identifier {
private:
  /// Name of array variable
  std::shared_ptr<Identifier> name;
  /// legth of an array or index position
  std::shared_ptr<Expression> length;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit IndexedName(Identifier *name, Expression *length);
  explicit IndexedName(const std::shared_ptr<Identifier> &name,
                       const std::shared_ptr<Expression> &length);
  IndexedName(const IndexedName &obj);

  virtual ~IndexedName() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::IndexedName
   * \return true as object is of type ast::IndexedName
   */
  bool is_indexed_name() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  IndexedName *clone() const override { return new IndexedName(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::INDEXED_NAME
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::INDEXED_NAME;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "IndexedName"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "IndexedName";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<IndexedName>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const IndexedName>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return name of the node
   *
   * Some ast nodes have a member marked designated as node name. For example,
   * in case of this ast::Identifier has name designated as a
   * node name.
   *
   * @return name of the node as std::string
   *
   * \sa Ast::get_node_type_name
   */
  std::string get_node_name() const override;

  /**
   * \brief Getter for member variable \ref IndexedName.name
   */
  const std::shared_ptr<Identifier> &get_name() const noexcept { return name; }

  /**
   * \brief Getter for member variable \ref IndexedName.length
   */
  const std::shared_ptr<Expression> &get_length() const noexcept {
    return length;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref IndexedName.name (rvalue reference)
   */
  void set_name(std::shared_ptr<Identifier> &&name);

  /**
   * \brief Setter for member variable \ref IndexedName.name
   */
  void set_name(const std::shared_ptr<Identifier> &name);

  /**
   * \brief Setter for member variable \ref IndexedName.length (rvalue
   * reference)
   */
  void set_length(std::shared_ptr<Expression> &&length);

  /**
   * \brief Setter for member variable \ref IndexedName.length
   */
  void set_length(const std::shared_ptr<Expression> &length);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_INDEXED_NAME_HPP
#ifndef NMODL_AST_VAR_NAME_HPP
#define NMODL_AST_VAR_NAME_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a variable
 *
 * This type was introduced to store variables of different types like
 * ast::Name or ast::IndexedName in the AST.
 *
 * \note With ast::Identifier as top level base class, this type can be
 * removed in the future refactoring.
 *
 */
class VarName : public Identifier {
private:
  /// Name of variable
  std::shared_ptr<Identifier> name;
  /// Value specified with `@`
  std::shared_ptr<Integer> at;
  /// index value in case of array
  std::shared_ptr<Expression> index;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit VarName(Identifier *name, Integer *at, Expression *index);
  explicit VarName(const std::shared_ptr<Identifier> &name,
                   const std::shared_ptr<Integer> &at,
                   const std::shared_ptr<Expression> &index);
  VarName(const VarName &obj);

  virtual ~VarName() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::VarName
   * \return true as object is of type ast::VarName
   */
  bool is_var_name() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  VarName *clone() const override { return new VarName(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::VAR_NAME
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::VAR_NAME;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "VarName"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override { return "VarName"; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<VarName>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const VarName>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return name of the node
   *
   * Some ast nodes have a member marked designated as node name. For example,
   * in case of this ast::Identifier has name designated as a
   * node name.
   *
   * @return name of the node as std::string
   *
   * \sa Ast::get_node_type_name
   */
  std::string get_node_name() const override;

  /**
   * \brief Getter for member variable \ref VarName.name
   */
  const std::shared_ptr<Identifier> &get_name() const noexcept { return name; }

  /**
   * \brief Getter for member variable \ref VarName.at
   */
  const std::shared_ptr<Integer> &get_at() const noexcept { return at; }

  /**
   * \brief Getter for member variable \ref VarName.index
   */
  const std::shared_ptr<Expression> &get_index() const noexcept {
    return index;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref VarName.name (rvalue reference)
   */
  void set_name(std::shared_ptr<Identifier> &&name);

  /**
   * \brief Setter for member variable \ref VarName.name
   */
  void set_name(const std::shared_ptr<Identifier> &name);

  /**
   * \brief Setter for member variable \ref VarName.at (rvalue reference)
   */
  void set_at(std::shared_ptr<Integer> &&at);

  /**
   * \brief Setter for member variable \ref VarName.at
   */
  void set_at(const std::shared_ptr<Integer> &at);

  /**
   * \brief Setter for member variable \ref VarName.index (rvalue reference)
   */
  void set_index(std::shared_ptr<Expression> &&index);

  /**
   * \brief Setter for member variable \ref VarName.index
   */
  void set_index(const std::shared_ptr<Expression> &index);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_VAR_NAME_HPP
#ifndef NMODL_AST_ARGUMENT_HPP
#define NMODL_AST_ARGUMENT_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents an argument to functions and procedures
 *
 * In case of function definitions from different ast nodes like
 * ast::FunctionBlock, ast::ProcedureBlock, the arguments are store in the
 * ast::Argument. For example, in below NMODL construct, `weight` is stored as
 * ast::Argument::name and `uS` is stored as ast::Argument::unit:
 *
 * \code {.mod}
 *     NET_RECEIVE(weight (uS)) {
 *         g = g + weight
 *     }
 * \endcode
 *
 */
class Argument : public Identifier {
private:
  /// Name of the argument
  std::shared_ptr<Identifier> name;
  /// Unit of the argument
  std::shared_ptr<Unit> unit;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit Argument(Identifier *name, Unit *unit);
  explicit Argument(const std::shared_ptr<Identifier> &name,
                    const std::shared_ptr<Unit> &unit);
  Argument(const Argument &obj);

  virtual ~Argument() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::Argument
   * \return true as object is of type ast::Argument
   */
  bool is_argument() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  Argument *clone() const override { return new Argument(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::ARGUMENT
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::ARGUMENT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Argument"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "Argument";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Argument>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Argument>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return name of the node
   *
   * Some ast nodes have a member marked designated as node name. For example,
   * in case of this ast::Identifier has name designated as a
   * node name.
   *
   * @return name of the node as std::string
   *
   * \sa Ast::get_node_type_name
   */
  std::string get_node_name() const override;

  /**
   * \brief Getter for member variable \ref Argument.name
   */
  const std::shared_ptr<Identifier> &get_name() const noexcept { return name; }

  /**
   * \brief Getter for member variable \ref Argument.unit
   */
  const std::shared_ptr<Unit> &get_unit() const noexcept { return unit; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref Argument.name (rvalue reference)
   */
  void set_name(std::shared_ptr<Identifier> &&name);

  /**
   * \brief Setter for member variable \ref Argument.name
   */
  void set_name(const std::shared_ptr<Identifier> &name);

  /**
   * \brief Setter for member variable \ref Argument.unit (rvalue reference)
   */
  void set_unit(std::shared_ptr<Unit> &&unit);

  /**
   * \brief Setter for member variable \ref Argument.unit
   */
  void set_unit(const std::shared_ptr<Unit> &unit);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_ARGUMENT_HPP
#ifndef NMODL_AST_REACT_VAR_NAME_HPP
#define NMODL_AST_REACT_VAR_NAME_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class ReactVarName : public Identifier {
private:
  /// TODO
  std::shared_ptr<Integer> value;
  /// TODO
  std::shared_ptr<VarName> name;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit ReactVarName(Integer *value, VarName *name);
  explicit ReactVarName(const std::shared_ptr<Integer> &value,
                        const std::shared_ptr<VarName> &name);
  ReactVarName(const ReactVarName &obj);

  virtual ~ReactVarName() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::ReactVarName
   * \return true as object is of type ast::ReactVarName
   */
  bool is_react_var_name() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  ReactVarName *clone() const override { return new ReactVarName(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::REACT_VAR_NAME
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::REACT_VAR_NAME;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "ReactVarName"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "ReactVarName";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<ReactVarName>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const ReactVarName>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref ReactVarName.value
   */
  const std::shared_ptr<Integer> &get_value() const noexcept { return value; }

  /**
   * \brief Return name of the node
   *
   * Some ast nodes have a member marked designated as node name. For example,
   * in case of this ast::VarName has name designated as a
   * node name.
   *
   * @return name of the node as std::string
   *
   * \sa Ast::get_node_type_name
   */
  std::string get_node_name() const override;

  /**
   * \brief Getter for member variable \ref ReactVarName.name
   */
  const std::shared_ptr<VarName> &get_name() const noexcept { return name; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref ReactVarName.value (rvalue
   * reference)
   */
  void set_value(std::shared_ptr<Integer> &&value);

  /**
   * \brief Setter for member variable \ref ReactVarName.value
   */
  void set_value(const std::shared_ptr<Integer> &value);

  /**
   * \brief Setter for member variable \ref ReactVarName.name (rvalue reference)
   */
  void set_name(std::shared_ptr<VarName> &&name);

  /**
   * \brief Setter for member variable \ref ReactVarName.name
   */
  void set_name(const std::shared_ptr<VarName> &name);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_REACT_VAR_NAME_HPP
#ifndef NMODL_AST_READ_ION_VAR_HPP
#define NMODL_AST_READ_ION_VAR_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class ReadIonVar : public Identifier {
private:
  /// TODO
  std::shared_ptr<Name> name;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit ReadIonVar(Name *name);
  explicit ReadIonVar(const std::shared_ptr<Name> &name);
  ReadIonVar(const ReadIonVar &obj);

  virtual ~ReadIonVar() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::ReadIonVar
   * \return true as object is of type ast::ReadIonVar
   */
  bool is_read_ion_var() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  ReadIonVar *clone() const override { return new ReadIonVar(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::READ_ION_VAR
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::READ_ION_VAR;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "ReadIonVar"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "ReadIonVar";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<ReadIonVar>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const ReadIonVar>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return name of the node
   *
   * Some ast nodes have a member marked designated as node name. For example,
   * in case of this ast::Name has name designated as a
   * node name.
   *
   * @return name of the node as std::string
   *
   * \sa Ast::get_node_type_name
   */
  std::string get_node_name() const override;

  /**
   * \brief Getter for member variable \ref ReadIonVar.name
   */
  const std::shared_ptr<Name> &get_name() const noexcept { return name; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref ReadIonVar.name (rvalue reference)
   */
  void set_name(std::shared_ptr<Name> &&name);

  /**
   * \brief Setter for member variable \ref ReadIonVar.name
   */
  void set_name(const std::shared_ptr<Name> &name);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_READ_ION_VAR_HPP
#ifndef NMODL_AST_WRITE_ION_VAR_HPP
#define NMODL_AST_WRITE_ION_VAR_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class WriteIonVar : public Identifier {
private:
  /// TODO
  std::shared_ptr<Name> name;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit WriteIonVar(Name *name);
  explicit WriteIonVar(const std::shared_ptr<Name> &name);
  WriteIonVar(const WriteIonVar &obj);

  virtual ~WriteIonVar() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::WriteIonVar
   * \return true as object is of type ast::WriteIonVar
   */
  bool is_write_ion_var() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  WriteIonVar *clone() const override { return new WriteIonVar(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::WRITE_ION_VAR
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::WRITE_ION_VAR;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "WriteIonVar"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "WriteIonVar";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<WriteIonVar>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const WriteIonVar>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return name of the node
   *
   * Some ast nodes have a member marked designated as node name. For example,
   * in case of this ast::Name has name designated as a
   * node name.
   *
   * @return name of the node as std::string
   *
   * \sa Ast::get_node_type_name
   */
  std::string get_node_name() const override;

  /**
   * \brief Getter for member variable \ref WriteIonVar.name
   */
  const std::shared_ptr<Name> &get_name() const noexcept { return name; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref WriteIonVar.name (rvalue reference)
   */
  void set_name(std::shared_ptr<Name> &&name);

  /**
   * \brief Setter for member variable \ref WriteIonVar.name
   */
  void set_name(const std::shared_ptr<Name> &name);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_WRITE_ION_VAR_HPP
#ifndef NMODL_AST_NONSPECIFIC_CUR_VAR_HPP
#define NMODL_AST_NONSPECIFIC_CUR_VAR_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class NonspecificCurVar : public Identifier {
private:
  /// TODO
  std::shared_ptr<Name> name;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit NonspecificCurVar(Name *name);
  explicit NonspecificCurVar(const std::shared_ptr<Name> &name);
  NonspecificCurVar(const NonspecificCurVar &obj);

  virtual ~NonspecificCurVar() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::NonspecificCurVar
   * \return true as object is of type ast::NonspecificCurVar
   */
  bool is_nonspecific_cur_var() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  NonspecificCurVar *clone() const override {
    return new NonspecificCurVar(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::NONSPECIFIC_CUR_VAR
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::NONSPECIFIC_CUR_VAR;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "NonspecificCurVar"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "NonspecificCurVar";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<NonspecificCurVar>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const NonspecificCurVar>(
        shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return name of the node
   *
   * Some ast nodes have a member marked designated as node name. For example,
   * in case of this ast::Name has name designated as a
   * node name.
   *
   * @return name of the node as std::string
   *
   * \sa Ast::get_node_type_name
   */
  std::string get_node_name() const override;

  /**
   * \brief Getter for member variable \ref NonspecificCurVar.name
   */
  const std::shared_ptr<Name> &get_name() const noexcept { return name; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref NonspecificCurVar.name (rvalue
   * reference)
   */
  void set_name(std::shared_ptr<Name> &&name);

  /**
   * \brief Setter for member variable \ref NonspecificCurVar.name
   */
  void set_name(const std::shared_ptr<Name> &name);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_NONSPECIFIC_CUR_VAR_HPP
#ifndef NMODL_AST_ELECTRODE_CUR_VAR_HPP
#define NMODL_AST_ELECTRODE_CUR_VAR_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class ElectrodeCurVar : public Identifier {
private:
  /// TODO
  std::shared_ptr<Name> name;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit ElectrodeCurVar(Name *name);
  explicit ElectrodeCurVar(const std::shared_ptr<Name> &name);
  ElectrodeCurVar(const ElectrodeCurVar &obj);

  virtual ~ElectrodeCurVar() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::ElectrodeCurVar
   * \return true as object is of type ast::ElectrodeCurVar
   */
  bool is_electrode_cur_var() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  ElectrodeCurVar *clone() const override { return new ElectrodeCurVar(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::ELECTRODE_CUR_VAR
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::ELECTRODE_CUR_VAR;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "ElectrodeCurVar"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "ElectrodeCurVar";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<ElectrodeCurVar>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const ElectrodeCurVar>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return name of the node
   *
   * Some ast nodes have a member marked designated as node name. For example,
   * in case of this ast::Name has name designated as a
   * node name.
   *
   * @return name of the node as std::string
   *
   * \sa Ast::get_node_type_name
   */
  std::string get_node_name() const override;

  /**
   * \brief Getter for member variable \ref ElectrodeCurVar.name
   */
  const std::shared_ptr<Name> &get_name() const noexcept { return name; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref ElectrodeCurVar.name (rvalue
   * reference)
   */
  void set_name(std::shared_ptr<Name> &&name);

  /**
   * \brief Setter for member variable \ref ElectrodeCurVar.name
   */
  void set_name(const std::shared_ptr<Name> &name);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_ELECTRODE_CUR_VAR_HPP
#ifndef NMODL_AST_SECTION_VAR_HPP
#define NMODL_AST_SECTION_VAR_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class SectionVar : public Identifier {
private:
  /// TODO
  std::shared_ptr<Name> name;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit SectionVar(Name *name);
  explicit SectionVar(const std::shared_ptr<Name> &name);
  SectionVar(const SectionVar &obj);

  virtual ~SectionVar() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::SectionVar
   * \return true as object is of type ast::SectionVar
   */
  bool is_section_var() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  SectionVar *clone() const override { return new SectionVar(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::SECTION_VAR
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::SECTION_VAR;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "SectionVar"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "SectionVar";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<SectionVar>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const SectionVar>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return name of the node
   *
   * Some ast nodes have a member marked designated as node name. For example,
   * in case of this ast::Name has name designated as a
   * node name.
   *
   * @return name of the node as std::string
   *
   * \sa Ast::get_node_type_name
   */
  std::string get_node_name() const override;

  /**
   * \brief Getter for member variable \ref SectionVar.name
   */
  const std::shared_ptr<Name> &get_name() const noexcept { return name; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref SectionVar.name (rvalue reference)
   */
  void set_name(std::shared_ptr<Name> &&name);

  /**
   * \brief Setter for member variable \ref SectionVar.name
   */
  void set_name(const std::shared_ptr<Name> &name);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_SECTION_VAR_HPP
#ifndef NMODL_AST_RANGE_VAR_HPP
#define NMODL_AST_RANGE_VAR_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class RangeVar : public Identifier {
private:
  /// TODO
  std::shared_ptr<Name> name;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit RangeVar(Name *name);
  explicit RangeVar(const std::shared_ptr<Name> &name);
  RangeVar(const RangeVar &obj);

  virtual ~RangeVar() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::RangeVar
   * \return true as object is of type ast::RangeVar
   */
  bool is_range_var() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  RangeVar *clone() const override { return new RangeVar(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::RANGE_VAR
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::RANGE_VAR;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "RangeVar"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "RangeVar";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<RangeVar>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const RangeVar>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return name of the node
   *
   * Some ast nodes have a member marked designated as node name. For example,
   * in case of this ast::Name has name designated as a
   * node name.
   *
   * @return name of the node as std::string
   *
   * \sa Ast::get_node_type_name
   */
  std::string get_node_name() const override;

  /**
   * \brief Getter for member variable \ref RangeVar.name
   */
  const std::shared_ptr<Name> &get_name() const noexcept { return name; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref RangeVar.name (rvalue reference)
   */
  void set_name(std::shared_ptr<Name> &&name);

  /**
   * \brief Setter for member variable \ref RangeVar.name
   */
  void set_name(const std::shared_ptr<Name> &name);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_RANGE_VAR_HPP
#ifndef NMODL_AST_GLOBAL_VAR_HPP
#define NMODL_AST_GLOBAL_VAR_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class GlobalVar : public Identifier {
private:
  /// TODO
  std::shared_ptr<Name> name;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit GlobalVar(Name *name);
  explicit GlobalVar(const std::shared_ptr<Name> &name);
  GlobalVar(const GlobalVar &obj);

  virtual ~GlobalVar() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::GlobalVar
   * \return true as object is of type ast::GlobalVar
   */
  bool is_global_var() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  GlobalVar *clone() const override { return new GlobalVar(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::GLOBAL_VAR
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::GLOBAL_VAR;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "GlobalVar"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "GlobalVar";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<GlobalVar>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const GlobalVar>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return name of the node
   *
   * Some ast nodes have a member marked designated as node name. For example,
   * in case of this ast::Name has name designated as a
   * node name.
   *
   * @return name of the node as std::string
   *
   * \sa Ast::get_node_type_name
   */
  std::string get_node_name() const override;

  /**
   * \brief Getter for member variable \ref GlobalVar.name
   */
  const std::shared_ptr<Name> &get_name() const noexcept { return name; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref GlobalVar.name (rvalue reference)
   */
  void set_name(std::shared_ptr<Name> &&name);

  /**
   * \brief Setter for member variable \ref GlobalVar.name
   */
  void set_name(const std::shared_ptr<Name> &name);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_GLOBAL_VAR_HPP
#ifndef NMODL_AST_POINTER_VAR_HPP
#define NMODL_AST_POINTER_VAR_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class PointerVar : public Identifier {
private:
  /// TODO
  std::shared_ptr<Name> name;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit PointerVar(Name *name);
  explicit PointerVar(const std::shared_ptr<Name> &name);
  PointerVar(const PointerVar &obj);

  virtual ~PointerVar() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::PointerVar
   * \return true as object is of type ast::PointerVar
   */
  bool is_pointer_var() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  PointerVar *clone() const override { return new PointerVar(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::POINTER_VAR
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::POINTER_VAR;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "PointerVar"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "PointerVar";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<PointerVar>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const PointerVar>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return name of the node
   *
   * Some ast nodes have a member marked designated as node name. For example,
   * in case of this ast::Name has name designated as a
   * node name.
   *
   * @return name of the node as std::string
   *
   * \sa Ast::get_node_type_name
   */
  std::string get_node_name() const override;

  /**
   * \brief Getter for member variable \ref PointerVar.name
   */
  const std::shared_ptr<Name> &get_name() const noexcept { return name; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref PointerVar.name (rvalue reference)
   */
  void set_name(std::shared_ptr<Name> &&name);

  /**
   * \brief Setter for member variable \ref PointerVar.name
   */
  void set_name(const std::shared_ptr<Name> &name);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_POINTER_VAR_HPP
#ifndef NMODL_AST_BBCORE_POINTER_VAR_HPP
#define NMODL_AST_BBCORE_POINTER_VAR_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represent a single variable of type BBCOREPOINTER
 *
 * See ast::BbcorePointer for an example.
 *
 */
class BbcorePointerVar : public Identifier {
private:
  /// Variable name
  std::shared_ptr<Name> name;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit BbcorePointerVar(Name *name);
  explicit BbcorePointerVar(const std::shared_ptr<Name> &name);
  BbcorePointerVar(const BbcorePointerVar &obj);

  virtual ~BbcorePointerVar() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::BbcorePointerVar
   * \return true as object is of type ast::BbcorePointerVar
   */
  bool is_bbcore_pointer_var() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  BbcorePointerVar *clone() const override {
    return new BbcorePointerVar(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::BBCORE_POINTER_VAR
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::BBCORE_POINTER_VAR;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "BbcorePointerVar"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "BbcorePointerVar";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<BbcorePointerVar>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const BbcorePointerVar>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return name of the node
   *
   * Some ast nodes have a member marked designated as node name. For example,
   * in case of this ast::Name has name designated as a
   * node name.
   *
   * @return name of the node as std::string
   *
   * \sa Ast::get_node_type_name
   */
  std::string get_node_name() const override;

  /**
   * \brief Getter for member variable \ref BbcorePointerVar.name
   */
  const std::shared_ptr<Name> &get_name() const noexcept { return name; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref BbcorePointerVar.name (rvalue
   * reference)
   */
  void set_name(std::shared_ptr<Name> &&name);

  /**
   * \brief Setter for member variable \ref BbcorePointerVar.name
   */
  void set_name(const std::shared_ptr<Name> &name);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_BBCORE_POINTER_VAR_HPP
#ifndef NMODL_AST_EXTERN_VAR_HPP
#define NMODL_AST_EXTERN_VAR_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class ExternVar : public Identifier {
private:
  /// TODO
  std::shared_ptr<Name> name;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit ExternVar(Name *name);
  explicit ExternVar(const std::shared_ptr<Name> &name);
  ExternVar(const ExternVar &obj);

  virtual ~ExternVar() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::ExternVar
   * \return true as object is of type ast::ExternVar
   */
  bool is_extern_var() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  ExternVar *clone() const override { return new ExternVar(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::EXTERN_VAR
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::EXTERN_VAR;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "ExternVar"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "ExternVar";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<ExternVar>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const ExternVar>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return name of the node
   *
   * Some ast nodes have a member marked designated as node name. For example,
   * in case of this ast::Name has name designated as a
   * node name.
   *
   * @return name of the node as std::string
   *
   * \sa Ast::get_node_type_name
   */
  std::string get_node_name() const override;

  /**
   * \brief Getter for member variable \ref ExternVar.name
   */
  const std::shared_ptr<Name> &get_name() const noexcept { return name; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref ExternVar.name (rvalue reference)
   */
  void set_name(std::shared_ptr<Name> &&name);

  /**
   * \brief Setter for member variable \ref ExternVar.name
   */
  void set_name(const std::shared_ptr<Name> &name);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_EXTERN_VAR_HPP
#ifndef NMODL_AST_THREADSAFE_VAR_HPP
#define NMODL_AST_THREADSAFE_VAR_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class ThreadsafeVar : public Identifier {
private:
  /// TODO
  std::shared_ptr<Name> name;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit ThreadsafeVar(Name *name);
  explicit ThreadsafeVar(const std::shared_ptr<Name> &name);
  ThreadsafeVar(const ThreadsafeVar &obj);

  virtual ~ThreadsafeVar() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::ThreadsafeVar
   * \return true as object is of type ast::ThreadsafeVar
   */
  bool is_threadsafe_var() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  ThreadsafeVar *clone() const override { return new ThreadsafeVar(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::THREADSAFE_VAR
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::THREADSAFE_VAR;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "ThreadsafeVar"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "ThreadsafeVar";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<ThreadsafeVar>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const ThreadsafeVar>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return name of the node
   *
   * Some ast nodes have a member marked designated as node name. For example,
   * in case of this ast::Name has name designated as a
   * node name.
   *
   * @return name of the node as std::string
   *
   * \sa Ast::get_node_type_name
   */
  std::string get_node_name() const override;

  /**
   * \brief Getter for member variable \ref ThreadsafeVar.name
   */
  const std::shared_ptr<Name> &get_name() const noexcept { return name; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref ThreadsafeVar.name (rvalue
   * reference)
   */
  void set_name(std::shared_ptr<Name> &&name);

  /**
   * \brief Setter for member variable \ref ThreadsafeVar.name
   */
  void set_name(const std::shared_ptr<Name> &name);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_THREADSAFE_VAR_HPP
#ifndef NMODL_AST_PARAM_BLOCK_HPP
#define NMODL_AST_PARAM_BLOCK_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a `PARAMETER` block in the NMODL
 *
 * Variables whose values are normally specified by the user are parameters
 * and are declared in a `PARAMETER` block. Here is an example :
 *
 * \code{.mod}
 *     PARAMETER {
 *         gkbar=.01   (mho/cm2) : Maximum Permeability
 *         d1 = .84
 *         k2 = .13e-6 (mM)
 *         abar = .28  (/ms)
 *         lcai (mV)
 *     }
 * \endcode
 *
 * All parameters are stored in the ast::ParamBlock::statements as vector.
 *
 */
class ParamBlock : public Block {
private:
  /// Vector of parameters
  ParamAssignVector statements;
  /// token with location information
  std::shared_ptr<ModToken> token;
  /// symbol table for a block
  symtab::SymbolTable *symtab = nullptr;

public:
  /// \name Ctor & dtor
  /// \{

  explicit ParamBlock(ParamAssignVector statements);
  ParamBlock(const ParamBlock &obj);

  virtual ~ParamBlock() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::ParamBlock
   * \return true as object is of type ast::ParamBlock
   */
  bool is_param_block() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  ParamBlock *clone() const override { return new ParamBlock(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::PARAM_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::PARAM_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "ParamBlock"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "ParamBlock";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "PARAMETER "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "PARAMETER "; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<ParamBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const ParamBlock>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return associated symbol table for the current ast node
   *
   * Only certain ast nodes (e.g. inherited from ast::Block) have associated
   * symbol table. These nodes have nmodl::symtab::SymbolTable as member
   * and it can be accessed using this method.
   *
   * \return pointer to the symbol table
   *
   * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
   */
  symtab::SymbolTable *get_symbol_table() const override { return symtab; }

  /**
   * \brief Getter for member variable \ref ParamBlock.statements
   */
  const ParamAssignVector &get_statements() const noexcept {
    return statements;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Set symbol table for the current ast node
   *
   * Top level, block scoped nodes store symbol table in the ast node.
   * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
   * for every node in the ast.
   *
   * \sa nmodl::visitor::SymtabVisitor
   */
  void set_symbol_table(symtab::SymbolTable *newsymtab) override {
    symtab = newsymtab;
  }

  /**
   * \brief Setter for member variable \ref ParamBlock.statements (rvalue
   * reference)
   */
  void set_statements(ParamAssignVector &&statements);

  /**
   * \brief Setter for member variable \ref ParamBlock.statements
   */
  void set_statements(const ParamAssignVector &statements);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_PARAM_BLOCK_HPP
#ifndef NMODL_AST_STEP_BLOCK_HPP
#define NMODL_AST_STEP_BLOCK_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a `STEPPED` block in the NMODL
 *
 * `STEPPED` has following form in the NMODL specification :
 *
 * \code{.mod}
 *     STEPPED {
 *         name1 = number1 (mM)
 *         name2 = number2, number3
 *     }
 * \endcode
 *
 * \todo Check ModelDB and other databse for example of channel.
 *
 */
class StepBlock : public Block {
private:
  /// Vector of statements
  SteppedVector statements;
  /// token with location information
  std::shared_ptr<ModToken> token;
  /// symbol table for a block
  symtab::SymbolTable *symtab = nullptr;

public:
  /// \name Ctor & dtor
  /// \{

  explicit StepBlock(SteppedVector statements);
  StepBlock(const StepBlock &obj);

  virtual ~StepBlock() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::StepBlock
   * \return true as object is of type ast::StepBlock
   */
  bool is_step_block() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  StepBlock *clone() const override { return new StepBlock(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::STEP_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::STEP_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "StepBlock"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "StepBlock";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "STEPPED "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "STEPPED "; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<StepBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const StepBlock>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return associated symbol table for the current ast node
   *
   * Only certain ast nodes (e.g. inherited from ast::Block) have associated
   * symbol table. These nodes have nmodl::symtab::SymbolTable as member
   * and it can be accessed using this method.
   *
   * \return pointer to the symbol table
   *
   * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
   */
  symtab::SymbolTable *get_symbol_table() const override { return symtab; }

  /**
   * \brief Getter for member variable \ref StepBlock.statements
   */
  const SteppedVector &get_statements() const noexcept { return statements; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Set symbol table for the current ast node
   *
   * Top level, block scoped nodes store symbol table in the ast node.
   * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
   * for every node in the ast.
   *
   * \sa nmodl::visitor::SymtabVisitor
   */
  void set_symbol_table(symtab::SymbolTable *newsymtab) override {
    symtab = newsymtab;
  }

  /**
   * \brief Setter for member variable \ref StepBlock.statements (rvalue
   * reference)
   */
  void set_statements(SteppedVector &&statements);

  /**
   * \brief Setter for member variable \ref StepBlock.statements
   */
  void set_statements(const SteppedVector &statements);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_STEP_BLOCK_HPP
#ifndef NMODL_AST_INDEPENDENT_BLOCK_HPP
#define NMODL_AST_INDEPENDENT_BLOCK_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a `INDEPENDENT` block in the NMODL
 *
 * `INDEPENDENT` has following form in the NMODL specification :
 *
 * \code{.mod}
 *     INDEPENDENT {
 *       t FROM 0 TO 1 WITH 1 (ms)
 *     }
 * \endcode
 *
 */
class IndependentBlock : public Block {
private:
  /// TODO
  IndependentDefinitionVector definitions;
  /// token with location information
  std::shared_ptr<ModToken> token;
  /// symbol table for a block
  symtab::SymbolTable *symtab = nullptr;

public:
  /// \name Ctor & dtor
  /// \{

  explicit IndependentBlock(IndependentDefinitionVector definitions);
  IndependentBlock(const IndependentBlock &obj);

  virtual ~IndependentBlock() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::IndependentBlock
   * \return true as object is of type ast::IndependentBlock
   */
  bool is_independent_block() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  IndependentBlock *clone() const override {
    return new IndependentBlock(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::INDEPENDENT_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::INDEPENDENT_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "IndependentBlock"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "IndependentBlock";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "INDEPENDENT "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override {
    return "INDEPENDENT ";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<IndependentBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const IndependentBlock>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return associated symbol table for the current ast node
   *
   * Only certain ast nodes (e.g. inherited from ast::Block) have associated
   * symbol table. These nodes have nmodl::symtab::SymbolTable as member
   * and it can be accessed using this method.
   *
   * \return pointer to the symbol table
   *
   * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
   */
  symtab::SymbolTable *get_symbol_table() const override { return symtab; }

  /**
   * \brief Getter for member variable \ref IndependentBlock.definitions
   */
  const IndependentDefinitionVector &get_definitions() const noexcept {
    return definitions;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Set symbol table for the current ast node
   *
   * Top level, block scoped nodes store symbol table in the ast node.
   * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
   * for every node in the ast.
   *
   * \sa nmodl::visitor::SymtabVisitor
   */
  void set_symbol_table(symtab::SymbolTable *newsymtab) override {
    symtab = newsymtab;
  }

  /**
   * \brief Setter for member variable \ref IndependentBlock.definitions (rvalue
   * reference)
   */
  void set_definitions(IndependentDefinitionVector &&definitions);

  /**
   * \brief Setter for member variable \ref IndependentBlock.definitions
   */
  void set_definitions(const IndependentDefinitionVector &definitions);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_INDEPENDENT_BLOCK_HPP
#ifndef NMODL_AST_ASSIGNED_BLOCK_HPP
#define NMODL_AST_ASSIGNED_BLOCK_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a `ASSIGNED` block in the NMODL
 *
 * The `ASSIGNED` block is used for declaring two kinds of variables :
 *   - those that are given values outside the mod files
 *   - those that appear on the left hand side of assignment statements within
 *     the mod file
 *
 * Below is an example of `ASSIGNED` block in the mod file:
 *
 * \code{.mod}
 *     ASSIGNED {
 *         ina     (mA/cm2)
 *         gna     (pS/um2)
 *         mtau (ms)   htau (ms)
 *         tadj
 *     }
 * \endcode
 *
 */
class AssignedBlock : public Block {
private:
  /// Vector of assigned variables
  AssignedDefinitionVector definitions;
  /// token with location information
  std::shared_ptr<ModToken> token;
  /// symbol table for a block
  symtab::SymbolTable *symtab = nullptr;

public:
  /// \name Ctor & dtor
  /// \{

  explicit AssignedBlock(AssignedDefinitionVector definitions);
  AssignedBlock(const AssignedBlock &obj);

  virtual ~AssignedBlock() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::AssignedBlock
   * \return true as object is of type ast::AssignedBlock
   */
  bool is_assigned_block() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  AssignedBlock *clone() const override { return new AssignedBlock(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::ASSIGNED_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::ASSIGNED_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "AssignedBlock"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "AssignedBlock";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "ASSIGNED "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "ASSIGNED "; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<AssignedBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const AssignedBlock>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return associated symbol table for the current ast node
   *
   * Only certain ast nodes (e.g. inherited from ast::Block) have associated
   * symbol table. These nodes have nmodl::symtab::SymbolTable as member
   * and it can be accessed using this method.
   *
   * \return pointer to the symbol table
   *
   * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
   */
  symtab::SymbolTable *get_symbol_table() const override { return symtab; }

  /**
   * \brief Getter for member variable \ref AssignedBlock.definitions
   */
  const AssignedDefinitionVector &get_definitions() const noexcept {
    return definitions;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Set symbol table for the current ast node
   *
   * Top level, block scoped nodes store symbol table in the ast node.
   * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
   * for every node in the ast.
   *
   * \sa nmodl::visitor::SymtabVisitor
   */
  void set_symbol_table(symtab::SymbolTable *newsymtab) override {
    symtab = newsymtab;
  }

  /**
   * \brief Setter for member variable \ref AssignedBlock.definitions (rvalue
   * reference)
   */
  void set_definitions(AssignedDefinitionVector &&definitions);

  /**
   * \brief Setter for member variable \ref AssignedBlock.definitions
   */
  void set_definitions(const AssignedDefinitionVector &definitions);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_ASSIGNED_BLOCK_HPP
#ifndef NMODL_AST_STATE_BLOCK_HPP
#define NMODL_AST_STATE_BLOCK_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a `STATE` block in the NMODL
 *
 * If a model involves differential equations, families of algebraic equations,
 * or kinetic reaction schemes, their dependent variables or unknowns are to be
 * listed in the `STATE` block. Below is an example of `STATE`:
 *
 *   \code{.mod}
 *       STATE {
 *           m
 *           h
 *       }
 *   \endcode
 *
 *   Note that the state variable specification has form of
 * ast::AssignedDefinition and hence can have associated unit specification.
 *
 */
class StateBlock : public Block {
private:
  /// Vector of state variables
  AssignedDefinitionVector definitions;
  /// token with location information
  std::shared_ptr<ModToken> token;
  /// symbol table for a block
  symtab::SymbolTable *symtab = nullptr;

public:
  /// \name Ctor & dtor
  /// \{

  explicit StateBlock(AssignedDefinitionVector definitions);
  StateBlock(const StateBlock &obj);

  virtual ~StateBlock() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::StateBlock
   * \return true as object is of type ast::StateBlock
   */
  bool is_state_block() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  StateBlock *clone() const override { return new StateBlock(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::STATE_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::STATE_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "StateBlock"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "StateBlock";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "STATE "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "STATE "; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<StateBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const StateBlock>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return associated symbol table for the current ast node
   *
   * Only certain ast nodes (e.g. inherited from ast::Block) have associated
   * symbol table. These nodes have nmodl::symtab::SymbolTable as member
   * and it can be accessed using this method.
   *
   * \return pointer to the symbol table
   *
   * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
   */
  symtab::SymbolTable *get_symbol_table() const override { return symtab; }

  /**
   * \brief Getter for member variable \ref StateBlock.definitions
   */
  const AssignedDefinitionVector &get_definitions() const noexcept {
    return definitions;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Set symbol table for the current ast node
   *
   * Top level, block scoped nodes store symbol table in the ast node.
   * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
   * for every node in the ast.
   *
   * \sa nmodl::visitor::SymtabVisitor
   */
  void set_symbol_table(symtab::SymbolTable *newsymtab) override {
    symtab = newsymtab;
  }

  /**
   * \brief Setter for member variable \ref StateBlock.definitions (rvalue
   * reference)
   */
  void set_definitions(AssignedDefinitionVector &&definitions);

  /**
   * \brief Setter for member variable \ref StateBlock.definitions
   */
  void set_definitions(const AssignedDefinitionVector &definitions);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_STATE_BLOCK_HPP
#ifndef NMODL_AST_PLOT_BLOCK_HPP
#define NMODL_AST_PLOT_BLOCK_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a `PLOT` statement in the NMODL
 *
 * `PLOT` construct doesn't have block scope but it's standalone, global scoped
 * statement of the form:
 *
 *   \code{.mod}
 *       PLOT name1, index_var2 VS name3
 *   \endcode
 *
 *   \todo Check ModelDB and other databse for example of channel.
 *
 */
class PlotBlock : public Block {
private:
  /// Vector of plot variables
  std::shared_ptr<PlotDeclaration> plot;
  /// token with location information
  std::shared_ptr<ModToken> token;
  /// symbol table for a block
  symtab::SymbolTable *symtab = nullptr;

public:
  /// \name Ctor & dtor
  /// \{

  explicit PlotBlock(PlotDeclaration *plot);
  explicit PlotBlock(const std::shared_ptr<PlotDeclaration> &plot);
  PlotBlock(const PlotBlock &obj);

  virtual ~PlotBlock() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::PlotBlock
   * \return true as object is of type ast::PlotBlock
   */
  bool is_plot_block() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  PlotBlock *clone() const override { return new PlotBlock(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::PLOT_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::PLOT_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "PlotBlock"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "PlotBlock";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<PlotBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const PlotBlock>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return associated symbol table for the current ast node
   *
   * Only certain ast nodes (e.g. inherited from ast::Block) have associated
   * symbol table. These nodes have nmodl::symtab::SymbolTable as member
   * and it can be accessed using this method.
   *
   * \return pointer to the symbol table
   *
   * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
   */
  symtab::SymbolTable *get_symbol_table() const override { return symtab; }

  /**
   * \brief Getter for member variable \ref PlotBlock.plot
   */
  const std::shared_ptr<PlotDeclaration> &get_plot() const noexcept {
    return plot;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Set symbol table for the current ast node
   *
   * Top level, block scoped nodes store symbol table in the ast node.
   * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
   * for every node in the ast.
   *
   * \sa nmodl::visitor::SymtabVisitor
   */
  void set_symbol_table(symtab::SymbolTable *newsymtab) override {
    symtab = newsymtab;
  }

  /**
   * \brief Setter for member variable \ref PlotBlock.plot (rvalue reference)
   */
  void set_plot(std::shared_ptr<PlotDeclaration> &&plot);

  /**
   * \brief Setter for member variable \ref PlotBlock.plot
   */
  void set_plot(const std::shared_ptr<PlotDeclaration> &plot);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_PLOT_BLOCK_HPP
#ifndef NMODL_AST_INITIAL_BLOCK_HPP
#define NMODL_AST_INITIAL_BLOCK_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a `INITIAL` block in the NMODL
 *
 * The code in the `INITIAL` block is executed when the hoc function
 * `finitialize()` is called. Here is an example :
 *
 *   \code{.mod}
 *       INITIAL {
 *           rates(v+vshift)
 *           m = minf
 *           h = hinf
 *           tadj = q10^((celsius - temp)/10)
 *       }
 *   \endcode
 *
 */
class InitialBlock : public Block {
private:
  /// Block with statements vector
  std::shared_ptr<StatementBlock> statement_block;
  /// token with location information
  std::shared_ptr<ModToken> token;
  /// symbol table for a block
  symtab::SymbolTable *symtab = nullptr;

public:
  /// \name Ctor & dtor
  /// \{

  explicit InitialBlock(StatementBlock *statement_block);
  explicit InitialBlock(const std::shared_ptr<StatementBlock> &statement_block);
  InitialBlock(const InitialBlock &obj);

  virtual ~InitialBlock() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::InitialBlock
   * \return true as object is of type ast::InitialBlock
   */
  bool is_initial_block() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  InitialBlock *clone() const override { return new InitialBlock(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::INITIAL_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::INITIAL_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "InitialBlock"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "InitialBlock";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "INITIAL "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "INITIAL "; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<InitialBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const InitialBlock>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return associated symbol table for the current ast node
   *
   * Only certain ast nodes (e.g. inherited from ast::Block) have associated
   * symbol table. These nodes have nmodl::symtab::SymbolTable as member
   * and it can be accessed using this method.
   *
   * \return pointer to the symbol table
   *
   * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
   */
  symtab::SymbolTable *get_symbol_table() const override { return symtab; }

  /**
   * \brief Getter for member variable \ref InitialBlock.statement_block
   */
  const std::shared_ptr<StatementBlock> &get_statement_block() const
      noexcept override {
    return statement_block;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Set symbol table for the current ast node
   *
   * Top level, block scoped nodes store symbol table in the ast node.
   * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
   * for every node in the ast.
   *
   * \sa nmodl::visitor::SymtabVisitor
   */
  void set_symbol_table(symtab::SymbolTable *newsymtab) override {
    symtab = newsymtab;
  }

  /**
   * \brief Setter for member variable \ref InitialBlock.statement_block (rvalue
   * reference)
   */
  void set_statement_block(std::shared_ptr<StatementBlock> &&statement_block);

  /**
   * \brief Setter for member variable \ref InitialBlock.statement_block
   */
  void
  set_statement_block(const std::shared_ptr<StatementBlock> &statement_block);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_INITIAL_BLOCK_HPP
#ifndef NMODL_AST_CONSTRUCTOR_BLOCK_HPP
#define NMODL_AST_CONSTRUCTOR_BLOCK_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a `CONSTRUCTOR` block in the NMODL
 *
 * The code in the `CONSTRUCTOR` is called when the channel is instantiated.
 * Like any other global block, `CONSTRUCTOR` block can have any statements. It
 * often used with `VERBATIM` block for initialization purpose :
 *
 *   \code{.mod}
 *       CONSTRUCTOR {
 *           VERBATIM
 *             if (ifarg(1)) { id= *getarg(1); } else { id= -1; }
 *           ENDVERBATIM
 *       }
 *   \endcode
 *
 *   \sa ast::DestructorBlock
 *
 */
class ConstructorBlock : public Block {
private:
  /// Block with statements vector
  std::shared_ptr<StatementBlock> statement_block;
  /// token with location information
  std::shared_ptr<ModToken> token;
  /// symbol table for a block
  symtab::SymbolTable *symtab = nullptr;

public:
  /// \name Ctor & dtor
  /// \{

  explicit ConstructorBlock(StatementBlock *statement_block);
  explicit ConstructorBlock(
      const std::shared_ptr<StatementBlock> &statement_block);
  ConstructorBlock(const ConstructorBlock &obj);

  virtual ~ConstructorBlock() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::ConstructorBlock
   * \return true as object is of type ast::ConstructorBlock
   */
  bool is_constructor_block() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  ConstructorBlock *clone() const override {
    return new ConstructorBlock(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::CONSTRUCTOR_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::CONSTRUCTOR_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "ConstructorBlock"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "ConstructorBlock";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "CONSTRUCTOR "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override {
    return "CONSTRUCTOR ";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<ConstructorBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const ConstructorBlock>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return associated symbol table for the current ast node
   *
   * Only certain ast nodes (e.g. inherited from ast::Block) have associated
   * symbol table. These nodes have nmodl::symtab::SymbolTable as member
   * and it can be accessed using this method.
   *
   * \return pointer to the symbol table
   *
   * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
   */
  symtab::SymbolTable *get_symbol_table() const override { return symtab; }

  /**
   * \brief Getter for member variable \ref ConstructorBlock.statement_block
   */
  const std::shared_ptr<StatementBlock> &get_statement_block() const
      noexcept override {
    return statement_block;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Set symbol table for the current ast node
   *
   * Top level, block scoped nodes store symbol table in the ast node.
   * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
   * for every node in the ast.
   *
   * \sa nmodl::visitor::SymtabVisitor
   */
  void set_symbol_table(symtab::SymbolTable *newsymtab) override {
    symtab = newsymtab;
  }

  /**
   * \brief Setter for member variable \ref ConstructorBlock.statement_block
   * (rvalue reference)
   */
  void set_statement_block(std::shared_ptr<StatementBlock> &&statement_block);

  /**
   * \brief Setter for member variable \ref ConstructorBlock.statement_block
   */
  void
  set_statement_block(const std::shared_ptr<StatementBlock> &statement_block);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_CONSTRUCTOR_BLOCK_HPP
#ifndef NMODL_AST_DESTRUCTOR_BLOCK_HPP
#define NMODL_AST_DESTRUCTOR_BLOCK_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a `DESTRUCTOR` block in the NMODL
 *
 * The code in the `DESTRUCTOR` is called when the channel instance is deleted.
 * It often used with `VERBATIM` block for finalization purpose :
 *
 *   \code{.mod}
 *       DESTRUCTOR {
 *           VERBATIM {
 *               nsyn = maxsyn = 0;
 *               free(PRECAST);
 *               link = 0;
 *           }
 *           ENDVERBATIM
 *       }
 *   \endcode
 *
 *   \sa ast::ConstructorBlock
 *
 */
class DestructorBlock : public Block {
private:
  /// Block with statements vector
  std::shared_ptr<StatementBlock> statement_block;
  /// token with location information
  std::shared_ptr<ModToken> token;
  /// symbol table for a block
  symtab::SymbolTable *symtab = nullptr;

public:
  /// \name Ctor & dtor
  /// \{

  explicit DestructorBlock(StatementBlock *statement_block);
  explicit DestructorBlock(
      const std::shared_ptr<StatementBlock> &statement_block);
  DestructorBlock(const DestructorBlock &obj);

  virtual ~DestructorBlock() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::DestructorBlock
   * \return true as object is of type ast::DestructorBlock
   */
  bool is_destructor_block() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  DestructorBlock *clone() const override { return new DestructorBlock(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::DESTRUCTOR_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::DESTRUCTOR_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "DestructorBlock"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "DestructorBlock";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "DESTRUCTOR "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "DESTRUCTOR "; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<DestructorBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const DestructorBlock>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return associated symbol table for the current ast node
   *
   * Only certain ast nodes (e.g. inherited from ast::Block) have associated
   * symbol table. These nodes have nmodl::symtab::SymbolTable as member
   * and it can be accessed using this method.
   *
   * \return pointer to the symbol table
   *
   * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
   */
  symtab::SymbolTable *get_symbol_table() const override { return symtab; }

  /**
   * \brief Getter for member variable \ref DestructorBlock.statement_block
   */
  const std::shared_ptr<StatementBlock> &get_statement_block() const
      noexcept override {
    return statement_block;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Set symbol table for the current ast node
   *
   * Top level, block scoped nodes store symbol table in the ast node.
   * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
   * for every node in the ast.
   *
   * \sa nmodl::visitor::SymtabVisitor
   */
  void set_symbol_table(symtab::SymbolTable *newsymtab) override {
    symtab = newsymtab;
  }

  /**
   * \brief Setter for member variable \ref DestructorBlock.statement_block
   * (rvalue reference)
   */
  void set_statement_block(std::shared_ptr<StatementBlock> &&statement_block);

  /**
   * \brief Setter for member variable \ref DestructorBlock.statement_block
   */
  void
  set_statement_block(const std::shared_ptr<StatementBlock> &statement_block);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_DESTRUCTOR_BLOCK_HPP
#ifndef NMODL_AST_STATEMENT_BLOCK_HPP
#define NMODL_AST_STATEMENT_BLOCK_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents block encapsulating list of statements
 *
 * Statement block is used to hold list of statements between `{ }`. This
 * represents a new block scope in the mod file and has following form :
 *
 *   \code{.mod}
 *       {
 *           statement1
 *           {
 *             statement2
 *           }
 *       }
 *   \endcode
 *
 *   Note that the statement blocks can be nested where inner block will
 *   be wrapped as statement with ast::ExpressionStatement.
 *
 */
class StatementBlock : public Block {
private:
  /// Vector of statements
  StatementVector statements;
  /// token with location information
  std::shared_ptr<ModToken> token;
  /// symbol table for a block
  symtab::SymbolTable *symtab = nullptr;

public:
  /// \name Ctor & dtor
  /// \{

  explicit StatementBlock(StatementVector statements);
  StatementBlock(const StatementBlock &obj);

  virtual ~StatementBlock() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::StatementBlock
   * \return true as object is of type ast::StatementBlock
   */
  bool is_statement_block() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  StatementBlock *clone() const override { return new StatementBlock(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::STATEMENT_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::STATEMENT_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "StatementBlock"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "StatementBlock";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<StatementBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const StatementBlock>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return associated symbol table for the current ast node
   *
   * Only certain ast nodes (e.g. inherited from ast::Block) have associated
   * symbol table. These nodes have nmodl::symtab::SymbolTable as member
   * and it can be accessed using this method.
   *
   * \return pointer to the symbol table
   *
   * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
   */
  symtab::SymbolTable *get_symbol_table() const override { return symtab; }

  /**
   * \brief Add member to statements by raw pointer
   */
  void emplace_back_statement(Statement *n) {
    statements.emplace_back(n);

    // set parents
    n->set_parent(this);
  }

  /**
   * \brief Add member to statements by shared_ptr
   */
  void emplace_back_statement(std::shared_ptr<Statement> n) {
    statements.emplace_back(n);
    // set parents
    n->set_parent(this);
  }

  /**
   * \brief Erase member to statements
   */
  StatementVector::const_iterator
  erase_statement(StatementVector::const_iterator first) {
    auto first_it = const_iter_cast(statements, first);
    return statements.erase(first_it);
  }
  /**
   * \brief Erase members to statements
   */
  StatementVector::const_iterator
  erase_statement(StatementVector::const_iterator first,
                  StatementVector::const_iterator last) {
    auto first_it = const_iter_cast(statements, first);
    auto last_it = const_iter_cast(statements, last);
    return statements.erase(first_it, last_it);
  }
  /**
   * \brief Erase non-consecutive members to statements
   *
   * loosely following the cpp reference of remove_if
   */
  size_t erase_statement(std::unordered_set<Statement *> &to_be_erased) {
    auto first = statements.begin();
    auto last = statements.end();
    auto result = first;

    while (first != last) {
      // automatically erase dangling pointers from the uset while
      // looking for them to erase them in the vector
      if (to_be_erased.erase(first->get()) == 0) {
        reset_statement(result, *first);
        ++result;
      }
      ++first;
    }

    size_t out = last - result;
    erase_statement(result, last);

    return out;
  }

  /**
   * \brief Insert member to statements
   */
  StatementVector::const_iterator
  insert_statement(StatementVector::const_iterator position,
                   const std::shared_ptr<Statement> &n) {
    n->set_parent(this);
    auto pos_it = const_iter_cast(statements, position);
    return statements.insert(pos_it, n);
  }
  /**
   * \brief Insert members to statements
   */
  template <class NodeType, class InputIterator>
  void insert_statement(StatementVector::const_iterator position, NodeType &to,
                        InputIterator first, InputIterator last) {

    for (auto it = first; it != last; ++it) {
      auto &n = *it;
      // set parents
      n->set_parent(this);
    }
    auto pos_it = const_iter_cast(statements, position);
    auto first_it = const_iter_cast(to, first);
    auto last_it = const_iter_cast(to, last);
    statements.insert(pos_it, first_it, last_it);
  }

  /**
   * \brief Reset member to statements
   */
  void reset_statement(StatementVector::const_iterator position, Statement *n) {
    // set parents
    n->set_parent(this);

    statements[position - statements.begin()].reset(n);
  }

  /**
   * \brief Reset member to statements
   */
  void reset_statement(StatementVector::const_iterator position,
                       std::shared_ptr<Statement> n) {
    // set parents
    n->set_parent(this);

    statements[position - statements.begin()] = n;
  }

  /**
   * \brief Getter for member variable \ref StatementBlock.statements
   */
  const StatementVector &get_statements() const noexcept { return statements; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Set symbol table for the current ast node
   *
   * Top level, block scoped nodes store symbol table in the ast node.
   * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
   * for every node in the ast.
   *
   * \sa nmodl::visitor::SymtabVisitor
   */
  void set_symbol_table(symtab::SymbolTable *newsymtab) override {
    symtab = newsymtab;
  }

  /**
   * \brief Setter for member variable \ref StatementBlock.statements (rvalue
   * reference)
   */
  void set_statements(StatementVector &&statements);

  /**
   * \brief Setter for member variable \ref StatementBlock.statements
   */
  void set_statements(const StatementVector &statements);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_STATEMENT_BLOCK_HPP
#ifndef NMODL_AST_DERIVATIVE_BLOCK_HPP
#define NMODL_AST_DERIVATIVE_BLOCK_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents `DERIVATIVE` block in the NMODL
 *
 * This block is used to assign values to the derivatives of those
 * `STATE`s that are described by differential equations. The statements
 * in this block are of the form \f$y' = expr\f$. Here is an example :
 *
 *   \code{.mod}
 *       DERIVATIVE states {
 *           rates(v)
 *           m' =  (minf-m)/mtau
 *           h' = (hinf-h)/htau
 *       }
 *   \endcode
 *
 */
class DerivativeBlock : public Block {
private:
  /// Name of the derivative block
  std::shared_ptr<Name> name;
  /// Block with statements vector
  std::shared_ptr<StatementBlock> statement_block;
  /// token with location information
  std::shared_ptr<ModToken> token;
  /// symbol table for a block
  symtab::SymbolTable *symtab = nullptr;

public:
  /// \name Ctor & dtor
  /// \{

  explicit DerivativeBlock(Name *name, StatementBlock *statement_block);
  explicit DerivativeBlock(
      const std::shared_ptr<Name> &name,
      const std::shared_ptr<StatementBlock> &statement_block);
  DerivativeBlock(const DerivativeBlock &obj);

  virtual ~DerivativeBlock() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::DerivativeBlock
   * \return true as object is of type ast::DerivativeBlock
   */
  bool is_derivative_block() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  DerivativeBlock *clone() const override { return new DerivativeBlock(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::DERIVATIVE_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::DERIVATIVE_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "DerivativeBlock"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "DerivativeBlock";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "DERIVATIVE "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "DERIVATIVE "; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<DerivativeBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const DerivativeBlock>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return associated symbol table for the current ast node
   *
   * Only certain ast nodes (e.g. inherited from ast::Block) have associated
   * symbol table. These nodes have nmodl::symtab::SymbolTable as member
   * and it can be accessed using this method.
   *
   * \return pointer to the symbol table
   *
   * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
   */
  symtab::SymbolTable *get_symbol_table() const override { return symtab; }

  /**
   * \brief Return name of the node
   *
   * Some ast nodes have a member marked designated as node name. For example,
   * in case of this ast::Name has name designated as a
   * node name.
   *
   * @return name of the node as std::string
   *
   * \sa Ast::get_node_type_name
   */
  std::string get_node_name() const override;

  /**
   * \brief Getter for member variable \ref DerivativeBlock.name
   */
  const std::shared_ptr<Name> &get_name() const noexcept { return name; }

  /**
   * \brief Getter for member variable \ref DerivativeBlock.statement_block
   */
  const std::shared_ptr<StatementBlock> &get_statement_block() const
      noexcept override {
    return statement_block;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Set symbol table for the current ast node
   *
   * Top level, block scoped nodes store symbol table in the ast node.
   * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
   * for every node in the ast.
   *
   * \sa nmodl::visitor::SymtabVisitor
   */
  void set_symbol_table(symtab::SymbolTable *newsymtab) override {
    symtab = newsymtab;
  }

  /**
   * \brief Setter for member variable \ref DerivativeBlock.name (rvalue
   * reference)
   */
  void set_name(std::shared_ptr<Name> &&name);

  /**
   * \brief Setter for member variable \ref DerivativeBlock.name
   */
  void set_name(const std::shared_ptr<Name> &name);

  /**
   * \brief Setter for member variable \ref DerivativeBlock.statement_block
   * (rvalue reference)
   */
  void set_statement_block(std::shared_ptr<StatementBlock> &&statement_block);

  /**
   * \brief Setter for member variable \ref DerivativeBlock.statement_block
   */
  void
  set_statement_block(const std::shared_ptr<StatementBlock> &statement_block);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_DERIVATIVE_BLOCK_HPP
#ifndef NMODL_AST_LINEAR_BLOCK_HPP
#define NMODL_AST_LINEAR_BLOCK_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents `LINEAR` block in the NMODL
 *
 *
 * A set of simultaneous equations can be specified in a `LINEAR` block.
 * Here is an example :
 *
 *   \code{.mod}
 *       LINEAR clamp {
 *           LOCAL t1, t2
 *           t1 = tau1/dt
 *           t2 = tau2/dt
 *           ~ vi = v + fac*vo - fac*v
 *           ~ t2*vo - t2*vo0 + vo = -gain * e
 *           ~ -stim - e  +  vi - e  +  t1*vi - t1*e - t1*(vi0 - e0) = 0
 *       }
 *   \endcode
 *
 */
class LinearBlock : public Block {
private:
  /// Name of the linear block
  std::shared_ptr<Name> name;
  /// TODO
  NameVector solvefor;
  /// Block with statements vector
  std::shared_ptr<StatementBlock> statement_block;
  /// token with location information
  std::shared_ptr<ModToken> token;
  /// symbol table for a block
  symtab::SymbolTable *symtab = nullptr;

public:
  /// \name Ctor & dtor
  /// \{

  explicit LinearBlock(Name *name, NameVector solvefor,
                       StatementBlock *statement_block);
  explicit LinearBlock(const std::shared_ptr<Name> &name,
                       const NameVector &solvefor,
                       const std::shared_ptr<StatementBlock> &statement_block);
  LinearBlock(const LinearBlock &obj);

  virtual ~LinearBlock() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::LinearBlock
   * \return true as object is of type ast::LinearBlock
   */
  bool is_linear_block() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  LinearBlock *clone() const override { return new LinearBlock(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::LINEAR_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::LINEAR_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "LinearBlock"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "LinearBlock";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "LINEAR "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "LINEAR "; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<LinearBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const LinearBlock>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return associated symbol table for the current ast node
   *
   * Only certain ast nodes (e.g. inherited from ast::Block) have associated
   * symbol table. These nodes have nmodl::symtab::SymbolTable as member
   * and it can be accessed using this method.
   *
   * \return pointer to the symbol table
   *
   * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
   */
  symtab::SymbolTable *get_symbol_table() const override { return symtab; }

  /**
   * \brief Return name of the node
   *
   * Some ast nodes have a member marked designated as node name. For example,
   * in case of this ast::Name has name designated as a
   * node name.
   *
   * @return name of the node as std::string
   *
   * \sa Ast::get_node_type_name
   */
  std::string get_node_name() const override;

  /**
   * \brief Getter for member variable \ref LinearBlock.name
   */
  const std::shared_ptr<Name> &get_name() const noexcept { return name; }

  /**
   * \brief Getter for member variable \ref LinearBlock.solvefor
   */
  const NameVector &get_solvefor() const noexcept { return solvefor; }

  /**
   * \brief Getter for member variable \ref LinearBlock.statement_block
   */
  const std::shared_ptr<StatementBlock> &get_statement_block() const
      noexcept override {
    return statement_block;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Set symbol table for the current ast node
   *
   * Top level, block scoped nodes store symbol table in the ast node.
   * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
   * for every node in the ast.
   *
   * \sa nmodl::visitor::SymtabVisitor
   */
  void set_symbol_table(symtab::SymbolTable *newsymtab) override {
    symtab = newsymtab;
  }

  /**
   * \brief Setter for member variable \ref LinearBlock.name (rvalue reference)
   */
  void set_name(std::shared_ptr<Name> &&name);

  /**
   * \brief Setter for member variable \ref LinearBlock.name
   */
  void set_name(const std::shared_ptr<Name> &name);

  /**
   * \brief Setter for member variable \ref LinearBlock.solvefor (rvalue
   * reference)
   */
  void set_solvefor(NameVector &&solvefor);

  /**
   * \brief Setter for member variable \ref LinearBlock.solvefor
   */
  void set_solvefor(const NameVector &solvefor);

  /**
   * \brief Setter for member variable \ref LinearBlock.statement_block (rvalue
   * reference)
   */
  void set_statement_block(std::shared_ptr<StatementBlock> &&statement_block);

  /**
   * \brief Setter for member variable \ref LinearBlock.statement_block
   */
  void
  set_statement_block(const std::shared_ptr<StatementBlock> &statement_block);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_LINEAR_BLOCK_HPP
#ifndef NMODL_AST_NON_LINEAR_BLOCK_HPP
#define NMODL_AST_NON_LINEAR_BLOCK_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents `NONLINEAR` block in the NMODL
 *
 *
 * A set of simultaneous equations can be specified in a `NONLINEAR` block.
 * Here is an example :
 *
 *   \code{.mod}
 *       NONLINEAR nonlin {
 *           ~ s[0] = 1
 *           ~ s[1] = 3
 *           ~ s[2] + s[1] = s[0]
 *       }
 *   \endcode
 *
 */
class NonLinearBlock : public Block {
private:
  /// Name of the non-linear block
  std::shared_ptr<Name> name;
  /// Name of the integration method
  NameVector solvefor;
  /// Block with statements vector
  std::shared_ptr<StatementBlock> statement_block;
  /// token with location information
  std::shared_ptr<ModToken> token;
  /// symbol table for a block
  symtab::SymbolTable *symtab = nullptr;

public:
  /// \name Ctor & dtor
  /// \{

  explicit NonLinearBlock(Name *name, NameVector solvefor,
                          StatementBlock *statement_block);
  explicit NonLinearBlock(
      const std::shared_ptr<Name> &name, const NameVector &solvefor,
      const std::shared_ptr<StatementBlock> &statement_block);
  NonLinearBlock(const NonLinearBlock &obj);

  virtual ~NonLinearBlock() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::NonLinearBlock
   * \return true as object is of type ast::NonLinearBlock
   */
  bool is_non_linear_block() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  NonLinearBlock *clone() const override { return new NonLinearBlock(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::NON_LINEAR_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::NON_LINEAR_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "NonLinearBlock"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "NonLinearBlock";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "NONLINEAR "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "NONLINEAR "; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<NonLinearBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const NonLinearBlock>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return associated symbol table for the current ast node
   *
   * Only certain ast nodes (e.g. inherited from ast::Block) have associated
   * symbol table. These nodes have nmodl::symtab::SymbolTable as member
   * and it can be accessed using this method.
   *
   * \return pointer to the symbol table
   *
   * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
   */
  symtab::SymbolTable *get_symbol_table() const override { return symtab; }

  /**
   * \brief Return name of the node
   *
   * Some ast nodes have a member marked designated as node name. For example,
   * in case of this ast::Name has name designated as a
   * node name.
   *
   * @return name of the node as std::string
   *
   * \sa Ast::get_node_type_name
   */
  std::string get_node_name() const override;

  /**
   * \brief Getter for member variable \ref NonLinearBlock.name
   */
  const std::shared_ptr<Name> &get_name() const noexcept { return name; }

  /**
   * \brief Getter for member variable \ref NonLinearBlock.solvefor
   */
  const NameVector &get_solvefor() const noexcept { return solvefor; }

  /**
   * \brief Getter for member variable \ref NonLinearBlock.statement_block
   */
  const std::shared_ptr<StatementBlock> &get_statement_block() const
      noexcept override {
    return statement_block;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Set symbol table for the current ast node
   *
   * Top level, block scoped nodes store symbol table in the ast node.
   * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
   * for every node in the ast.
   *
   * \sa nmodl::visitor::SymtabVisitor
   */
  void set_symbol_table(symtab::SymbolTable *newsymtab) override {
    symtab = newsymtab;
  }

  /**
   * \brief Setter for member variable \ref NonLinearBlock.name (rvalue
   * reference)
   */
  void set_name(std::shared_ptr<Name> &&name);

  /**
   * \brief Setter for member variable \ref NonLinearBlock.name
   */
  void set_name(const std::shared_ptr<Name> &name);

  /**
   * \brief Setter for member variable \ref NonLinearBlock.solvefor (rvalue
   * reference)
   */
  void set_solvefor(NameVector &&solvefor);

  /**
   * \brief Setter for member variable \ref NonLinearBlock.solvefor
   */
  void set_solvefor(const NameVector &solvefor);

  /**
   * \brief Setter for member variable \ref NonLinearBlock.statement_block
   * (rvalue reference)
   */
  void set_statement_block(std::shared_ptr<StatementBlock> &&statement_block);

  /**
   * \brief Setter for member variable \ref NonLinearBlock.statement_block
   */
  void
  set_statement_block(const std::shared_ptr<StatementBlock> &statement_block);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_NON_LINEAR_BLOCK_HPP
#ifndef NMODL_AST_DISCRETE_BLOCK_HPP
#define NMODL_AST_DISCRETE_BLOCK_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class DiscreteBlock : public Block {
private:
  /// Name of the discrete block
  std::shared_ptr<Name> name;
  /// Block with statements vector
  std::shared_ptr<StatementBlock> statement_block;
  /// token with location information
  std::shared_ptr<ModToken> token;
  /// symbol table for a block
  symtab::SymbolTable *symtab = nullptr;

public:
  /// \name Ctor & dtor
  /// \{

  explicit DiscreteBlock(Name *name, StatementBlock *statement_block);
  explicit DiscreteBlock(
      const std::shared_ptr<Name> &name,
      const std::shared_ptr<StatementBlock> &statement_block);
  DiscreteBlock(const DiscreteBlock &obj);

  virtual ~DiscreteBlock() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::DiscreteBlock
   * \return true as object is of type ast::DiscreteBlock
   */
  bool is_discrete_block() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  DiscreteBlock *clone() const override { return new DiscreteBlock(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::DISCRETE_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::DISCRETE_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "DiscreteBlock"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "DiscreteBlock";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "DISCRETE "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "DISCRETE "; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<DiscreteBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const DiscreteBlock>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return associated symbol table for the current ast node
   *
   * Only certain ast nodes (e.g. inherited from ast::Block) have associated
   * symbol table. These nodes have nmodl::symtab::SymbolTable as member
   * and it can be accessed using this method.
   *
   * \return pointer to the symbol table
   *
   * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
   */
  symtab::SymbolTable *get_symbol_table() const override { return symtab; }

  /**
   * \brief Return name of the node
   *
   * Some ast nodes have a member marked designated as node name. For example,
   * in case of this ast::Name has name designated as a
   * node name.
   *
   * @return name of the node as std::string
   *
   * \sa Ast::get_node_type_name
   */
  std::string get_node_name() const override;

  /**
   * \brief Getter for member variable \ref DiscreteBlock.name
   */
  const std::shared_ptr<Name> &get_name() const noexcept { return name; }

  /**
   * \brief Getter for member variable \ref DiscreteBlock.statement_block
   */
  const std::shared_ptr<StatementBlock> &get_statement_block() const
      noexcept override {
    return statement_block;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Set symbol table for the current ast node
   *
   * Top level, block scoped nodes store symbol table in the ast node.
   * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
   * for every node in the ast.
   *
   * \sa nmodl::visitor::SymtabVisitor
   */
  void set_symbol_table(symtab::SymbolTable *newsymtab) override {
    symtab = newsymtab;
  }

  /**
   * \brief Setter for member variable \ref DiscreteBlock.name (rvalue
   * reference)
   */
  void set_name(std::shared_ptr<Name> &&name);

  /**
   * \brief Setter for member variable \ref DiscreteBlock.name
   */
  void set_name(const std::shared_ptr<Name> &name);

  /**
   * \brief Setter for member variable \ref DiscreteBlock.statement_block
   * (rvalue reference)
   */
  void set_statement_block(std::shared_ptr<StatementBlock> &&statement_block);

  /**
   * \brief Setter for member variable \ref DiscreteBlock.statement_block
   */
  void
  set_statement_block(const std::shared_ptr<StatementBlock> &statement_block);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_DISCRETE_BLOCK_HPP
#ifndef NMODL_AST_PARTIAL_BLOCK_HPP
#define NMODL_AST_PARTIAL_BLOCK_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class PartialBlock : public Block {
private:
  /// Name of the partial block
  std::shared_ptr<Name> name;
  /// Block with statements vector
  std::shared_ptr<StatementBlock> statement_block;
  /// token with location information
  std::shared_ptr<ModToken> token;
  /// symbol table for a block
  symtab::SymbolTable *symtab = nullptr;

public:
  /// \name Ctor & dtor
  /// \{

  explicit PartialBlock(Name *name, StatementBlock *statement_block);
  explicit PartialBlock(const std::shared_ptr<Name> &name,
                        const std::shared_ptr<StatementBlock> &statement_block);
  PartialBlock(const PartialBlock &obj);

  virtual ~PartialBlock() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::PartialBlock
   * \return true as object is of type ast::PartialBlock
   */
  bool is_partial_block() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  PartialBlock *clone() const override { return new PartialBlock(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::PARTIAL_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::PARTIAL_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "PartialBlock"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "PartialBlock";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "PARTIAL "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "PARTIAL "; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<PartialBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const PartialBlock>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return associated symbol table for the current ast node
   *
   * Only certain ast nodes (e.g. inherited from ast::Block) have associated
   * symbol table. These nodes have nmodl::symtab::SymbolTable as member
   * and it can be accessed using this method.
   *
   * \return pointer to the symbol table
   *
   * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
   */
  symtab::SymbolTable *get_symbol_table() const override { return symtab; }

  /**
   * \brief Return name of the node
   *
   * Some ast nodes have a member marked designated as node name. For example,
   * in case of this ast::Name has name designated as a
   * node name.
   *
   * @return name of the node as std::string
   *
   * \sa Ast::get_node_type_name
   */
  std::string get_node_name() const override;

  /**
   * \brief Getter for member variable \ref PartialBlock.name
   */
  const std::shared_ptr<Name> &get_name() const noexcept { return name; }

  /**
   * \brief Getter for member variable \ref PartialBlock.statement_block
   */
  const std::shared_ptr<StatementBlock> &get_statement_block() const
      noexcept override {
    return statement_block;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Set symbol table for the current ast node
   *
   * Top level, block scoped nodes store symbol table in the ast node.
   * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
   * for every node in the ast.
   *
   * \sa nmodl::visitor::SymtabVisitor
   */
  void set_symbol_table(symtab::SymbolTable *newsymtab) override {
    symtab = newsymtab;
  }

  /**
   * \brief Setter for member variable \ref PartialBlock.name (rvalue reference)
   */
  void set_name(std::shared_ptr<Name> &&name);

  /**
   * \brief Setter for member variable \ref PartialBlock.name
   */
  void set_name(const std::shared_ptr<Name> &name);

  /**
   * \brief Setter for member variable \ref PartialBlock.statement_block (rvalue
   * reference)
   */
  void set_statement_block(std::shared_ptr<StatementBlock> &&statement_block);

  /**
   * \brief Setter for member variable \ref PartialBlock.statement_block
   */
  void
  set_statement_block(const std::shared_ptr<StatementBlock> &statement_block);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_PARTIAL_BLOCK_HPP
#ifndef NMODL_AST_FUNCTION_TABLE_BLOCK_HPP
#define NMODL_AST_FUNCTION_TABLE_BLOCK_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class FunctionTableBlock : public Block {
private:
  /// Name of the function table block
  std::shared_ptr<Name> name;
  /// Vector of the parameters
  ArgumentVector parameters;
  /// Unit if specified
  std::shared_ptr<Unit> unit;
  /// token with location information
  std::shared_ptr<ModToken> token;
  /// symbol table for a block
  symtab::SymbolTable *symtab = nullptr;

public:
  /// \name Ctor & dtor
  /// \{

  explicit FunctionTableBlock(Name *name, ArgumentVector parameters,
                              Unit *unit);
  explicit FunctionTableBlock(const std::shared_ptr<Name> &name,
                              const ArgumentVector &parameters,
                              const std::shared_ptr<Unit> &unit);
  FunctionTableBlock(const FunctionTableBlock &obj);

  virtual ~FunctionTableBlock() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::FunctionTableBlock
   * \return true as object is of type ast::FunctionTableBlock
   */
  bool is_function_table_block() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  FunctionTableBlock *clone() const override {
    return new FunctionTableBlock(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::FUNCTION_TABLE_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::FUNCTION_TABLE_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "FunctionTableBlock"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "FunctionTableBlock";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "FUNCTION_TABLE "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override {
    return "FUNCTION_TABLE ";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<FunctionTableBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const FunctionTableBlock>(
        shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return associated symbol table for the current ast node
   *
   * Only certain ast nodes (e.g. inherited from ast::Block) have associated
   * symbol table. These nodes have nmodl::symtab::SymbolTable as member
   * and it can be accessed using this method.
   *
   * \return pointer to the symbol table
   *
   * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
   */
  symtab::SymbolTable *get_symbol_table() const override { return symtab; }

  /**
   * \brief Return name of the node
   *
   * Some ast nodes have a member marked designated as node name. For example,
   * in case of this ast::Name has name designated as a
   * node name.
   *
   * @return name of the node as std::string
   *
   * \sa Ast::get_node_type_name
   */
  std::string get_node_name() const override;

  /**
   * \brief Getter for member variable \ref FunctionTableBlock.name
   */
  const std::shared_ptr<Name> &get_name() const noexcept { return name; }

  /**
   * \brief Getter for member variable \ref FunctionTableBlock.parameters
   */
  const ArgumentVector &get_parameters() const noexcept override {
    return parameters;
  }

  /**
   * \brief Getter for member variable \ref FunctionTableBlock.unit
   */
  const std::shared_ptr<Unit> &get_unit() const noexcept { return unit; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Set symbol table for the current ast node
   *
   * Top level, block scoped nodes store symbol table in the ast node.
   * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
   * for every node in the ast.
   *
   * \sa nmodl::visitor::SymtabVisitor
   */
  void set_symbol_table(symtab::SymbolTable *newsymtab) override {
    symtab = newsymtab;
  }

  /**
   * \brief Setter for member variable \ref FunctionTableBlock.name (rvalue
   * reference)
   */
  void set_name(std::shared_ptr<Name> &&name);

  /**
   * \brief Setter for member variable \ref FunctionTableBlock.name
   */
  void set_name(const std::shared_ptr<Name> &name);

  /**
   * \brief Setter for member variable \ref FunctionTableBlock.parameters
   * (rvalue reference)
   */
  void set_parameters(ArgumentVector &&parameters);

  /**
   * \brief Setter for member variable \ref FunctionTableBlock.parameters
   */
  void set_parameters(const ArgumentVector &parameters);

  /**
   * \brief Setter for member variable \ref FunctionTableBlock.unit (rvalue
   * reference)
   */
  void set_unit(std::shared_ptr<Unit> &&unit);

  /**
   * \brief Setter for member variable \ref FunctionTableBlock.unit
   */
  void set_unit(const std::shared_ptr<Unit> &unit);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_FUNCTION_TABLE_BLOCK_HPP
#ifndef NMODL_AST_FUNCTION_BLOCK_HPP
#define NMODL_AST_FUNCTION_BLOCK_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class FunctionBlock : public Block {
private:
  /// Name of the function
  std::shared_ptr<Name> name;
  /// Vector of the parameters
  ArgumentVector parameters;
  /// Unit if specified
  std::shared_ptr<Unit> unit;
  /// Block with statements vector
  std::shared_ptr<StatementBlock> statement_block;
  /// token with location information
  std::shared_ptr<ModToken> token;
  /// symbol table for a block
  symtab::SymbolTable *symtab = nullptr;

public:
  /// \name Ctor & dtor
  /// \{

  explicit FunctionBlock(Name *name, ArgumentVector parameters, Unit *unit,
                         StatementBlock *statement_block);
  explicit FunctionBlock(
      const std::shared_ptr<Name> &name, const ArgumentVector &parameters,
      const std::shared_ptr<Unit> &unit,
      const std::shared_ptr<StatementBlock> &statement_block);
  FunctionBlock(const FunctionBlock &obj);

  virtual ~FunctionBlock() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::FunctionBlock
   * \return true as object is of type ast::FunctionBlock
   */
  bool is_function_block() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  FunctionBlock *clone() const override { return new FunctionBlock(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::FUNCTION_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::FUNCTION_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "FunctionBlock"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "FunctionBlock";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "FUNCTION "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "FUNCTION "; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<FunctionBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const FunctionBlock>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return associated symbol table for the current ast node
   *
   * Only certain ast nodes (e.g. inherited from ast::Block) have associated
   * symbol table. These nodes have nmodl::symtab::SymbolTable as member
   * and it can be accessed using this method.
   *
   * \return pointer to the symbol table
   *
   * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
   */
  symtab::SymbolTable *get_symbol_table() const override { return symtab; }

  /**
   * \brief Return name of the node
   *
   * Some ast nodes have a member marked designated as node name. For example,
   * in case of this ast::Name has name designated as a
   * node name.
   *
   * @return name of the node as std::string
   *
   * \sa Ast::get_node_type_name
   */
  std::string get_node_name() const override;

  /**
   * \brief Getter for member variable \ref FunctionBlock.name
   */
  const std::shared_ptr<Name> &get_name() const noexcept { return name; }

  /**
   * \brief Getter for member variable \ref FunctionBlock.parameters
   */
  const ArgumentVector &get_parameters() const noexcept override {
    return parameters;
  }

  /**
   * \brief Getter for member variable \ref FunctionBlock.unit
   */
  const std::shared_ptr<Unit> &get_unit() const noexcept { return unit; }

  /**
   * \brief Getter for member variable \ref FunctionBlock.statement_block
   */
  const std::shared_ptr<StatementBlock> &get_statement_block() const
      noexcept override {
    return statement_block;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Set symbol table for the current ast node
   *
   * Top level, block scoped nodes store symbol table in the ast node.
   * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
   * for every node in the ast.
   *
   * \sa nmodl::visitor::SymtabVisitor
   */
  void set_symbol_table(symtab::SymbolTable *newsymtab) override {
    symtab = newsymtab;
  }

  /**
   * \brief Setter for member variable \ref FunctionBlock.name (rvalue
   * reference)
   */
  void set_name(std::shared_ptr<Name> &&name);

  /**
   * \brief Setter for member variable \ref FunctionBlock.name
   */
  void set_name(const std::shared_ptr<Name> &name);

  /**
   * \brief Setter for member variable \ref FunctionBlock.parameters (rvalue
   * reference)
   */
  void set_parameters(ArgumentVector &&parameters);

  /**
   * \brief Setter for member variable \ref FunctionBlock.parameters
   */
  void set_parameters(const ArgumentVector &parameters);

  /**
   * \brief Setter for member variable \ref FunctionBlock.unit (rvalue
   * reference)
   */
  void set_unit(std::shared_ptr<Unit> &&unit);

  /**
   * \brief Setter for member variable \ref FunctionBlock.unit
   */
  void set_unit(const std::shared_ptr<Unit> &unit);

  /**
   * \brief Setter for member variable \ref FunctionBlock.statement_block
   * (rvalue reference)
   */
  void set_statement_block(std::shared_ptr<StatementBlock> &&statement_block);

  /**
   * \brief Setter for member variable \ref FunctionBlock.statement_block
   */
  void
  set_statement_block(const std::shared_ptr<StatementBlock> &statement_block);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_FUNCTION_BLOCK_HPP
#ifndef NMODL_AST_PROCEDURE_BLOCK_HPP
#define NMODL_AST_PROCEDURE_BLOCK_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class ProcedureBlock : public Block {
private:
  /// Name of the procedure
  std::shared_ptr<Name> name;
  /// Vector of the parameters
  ArgumentVector parameters;
  /// Unit if specified
  std::shared_ptr<Unit> unit;
  /// Block with statements vector
  std::shared_ptr<StatementBlock> statement_block;
  /// token with location information
  std::shared_ptr<ModToken> token;
  /// symbol table for a block
  symtab::SymbolTable *symtab = nullptr;

public:
  /// \name Ctor & dtor
  /// \{

  explicit ProcedureBlock(Name *name, ArgumentVector parameters, Unit *unit,
                          StatementBlock *statement_block);
  explicit ProcedureBlock(
      const std::shared_ptr<Name> &name, const ArgumentVector &parameters,
      const std::shared_ptr<Unit> &unit,
      const std::shared_ptr<StatementBlock> &statement_block);
  ProcedureBlock(const ProcedureBlock &obj);

  virtual ~ProcedureBlock() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::ProcedureBlock
   * \return true as object is of type ast::ProcedureBlock
   */
  bool is_procedure_block() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  ProcedureBlock *clone() const override { return new ProcedureBlock(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::PROCEDURE_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::PROCEDURE_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "ProcedureBlock"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "ProcedureBlock";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "PROCEDURE "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "PROCEDURE "; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<ProcedureBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const ProcedureBlock>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return associated symbol table for the current ast node
   *
   * Only certain ast nodes (e.g. inherited from ast::Block) have associated
   * symbol table. These nodes have nmodl::symtab::SymbolTable as member
   * and it can be accessed using this method.
   *
   * \return pointer to the symbol table
   *
   * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
   */
  symtab::SymbolTable *get_symbol_table() const override { return symtab; }

  /**
   * \brief Return name of the node
   *
   * Some ast nodes have a member marked designated as node name. For example,
   * in case of this ast::Name has name designated as a
   * node name.
   *
   * @return name of the node as std::string
   *
   * \sa Ast::get_node_type_name
   */
  std::string get_node_name() const override;

  /**
   * \brief Getter for member variable \ref ProcedureBlock.name
   */
  const std::shared_ptr<Name> &get_name() const noexcept { return name; }

  /**
   * \brief Getter for member variable \ref ProcedureBlock.parameters
   */
  const ArgumentVector &get_parameters() const noexcept override {
    return parameters;
  }

  /**
   * \brief Getter for member variable \ref ProcedureBlock.unit
   */
  const std::shared_ptr<Unit> &get_unit() const noexcept { return unit; }

  /**
   * \brief Getter for member variable \ref ProcedureBlock.statement_block
   */
  const std::shared_ptr<StatementBlock> &get_statement_block() const
      noexcept override {
    return statement_block;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Set symbol table for the current ast node
   *
   * Top level, block scoped nodes store symbol table in the ast node.
   * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
   * for every node in the ast.
   *
   * \sa nmodl::visitor::SymtabVisitor
   */
  void set_symbol_table(symtab::SymbolTable *newsymtab) override {
    symtab = newsymtab;
  }

  /**
   * \brief Setter for member variable \ref ProcedureBlock.name (rvalue
   * reference)
   */
  void set_name(std::shared_ptr<Name> &&name);

  /**
   * \brief Setter for member variable \ref ProcedureBlock.name
   */
  void set_name(const std::shared_ptr<Name> &name);

  /**
   * \brief Setter for member variable \ref ProcedureBlock.parameters (rvalue
   * reference)
   */
  void set_parameters(ArgumentVector &&parameters);

  /**
   * \brief Setter for member variable \ref ProcedureBlock.parameters
   */
  void set_parameters(const ArgumentVector &parameters);

  /**
   * \brief Setter for member variable \ref ProcedureBlock.unit (rvalue
   * reference)
   */
  void set_unit(std::shared_ptr<Unit> &&unit);

  /**
   * \brief Setter for member variable \ref ProcedureBlock.unit
   */
  void set_unit(const std::shared_ptr<Unit> &unit);

  /**
   * \brief Setter for member variable \ref ProcedureBlock.statement_block
   * (rvalue reference)
   */
  void set_statement_block(std::shared_ptr<StatementBlock> &&statement_block);

  /**
   * \brief Setter for member variable \ref ProcedureBlock.statement_block
   */
  void
  set_statement_block(const std::shared_ptr<StatementBlock> &statement_block);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_PROCEDURE_BLOCK_HPP
#ifndef NMODL_AST_NET_RECEIVE_BLOCK_HPP
#define NMODL_AST_NET_RECEIVE_BLOCK_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class NetReceiveBlock : public Block {
private:
  /// Parameters to the net receive block
  ArgumentVector parameters;
  /// Block with statements vector
  std::shared_ptr<StatementBlock> statement_block;
  /// token with location information
  std::shared_ptr<ModToken> token;
  /// symbol table for a block
  symtab::SymbolTable *symtab = nullptr;

public:
  /// \name Ctor & dtor
  /// \{

  explicit NetReceiveBlock(ArgumentVector parameters,
                           StatementBlock *statement_block);
  explicit NetReceiveBlock(
      const ArgumentVector &parameters,
      const std::shared_ptr<StatementBlock> &statement_block);
  NetReceiveBlock(const NetReceiveBlock &obj);

  virtual ~NetReceiveBlock() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::NetReceiveBlock
   * \return true as object is of type ast::NetReceiveBlock
   */
  bool is_net_receive_block() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  NetReceiveBlock *clone() const override { return new NetReceiveBlock(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::NET_RECEIVE_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::NET_RECEIVE_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "NetReceiveBlock"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "NetReceiveBlock";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "NET_RECEIVE "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override {
    return "NET_RECEIVE ";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<NetReceiveBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const NetReceiveBlock>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return associated symbol table for the current ast node
   *
   * Only certain ast nodes (e.g. inherited from ast::Block) have associated
   * symbol table. These nodes have nmodl::symtab::SymbolTable as member
   * and it can be accessed using this method.
   *
   * \return pointer to the symbol table
   *
   * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
   */
  symtab::SymbolTable *get_symbol_table() const override { return symtab; }

  /**
   * \brief Getter for member variable \ref NetReceiveBlock.parameters
   */
  const ArgumentVector &get_parameters() const noexcept override {
    return parameters;
  }

  /**
   * \brief Getter for member variable \ref NetReceiveBlock.statement_block
   */
  const std::shared_ptr<StatementBlock> &get_statement_block() const
      noexcept override {
    return statement_block;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Set symbol table for the current ast node
   *
   * Top level, block scoped nodes store symbol table in the ast node.
   * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
   * for every node in the ast.
   *
   * \sa nmodl::visitor::SymtabVisitor
   */
  void set_symbol_table(symtab::SymbolTable *newsymtab) override {
    symtab = newsymtab;
  }

  /**
   * \brief Setter for member variable \ref NetReceiveBlock.parameters (rvalue
   * reference)
   */
  void set_parameters(ArgumentVector &&parameters);

  /**
   * \brief Setter for member variable \ref NetReceiveBlock.parameters
   */
  void set_parameters(const ArgumentVector &parameters);

  /**
   * \brief Setter for member variable \ref NetReceiveBlock.statement_block
   * (rvalue reference)
   */
  void set_statement_block(std::shared_ptr<StatementBlock> &&statement_block);

  /**
   * \brief Setter for member variable \ref NetReceiveBlock.statement_block
   */
  void
  set_statement_block(const std::shared_ptr<StatementBlock> &statement_block);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_NET_RECEIVE_BLOCK_HPP
#ifndef NMODL_AST_SOLVE_BLOCK_HPP
#define NMODL_AST_SOLVE_BLOCK_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class SolveBlock : public Block {
private:
  /// Name of the block to solve
  std::shared_ptr<Name> block_name;
  /// Name of the integration method
  std::shared_ptr<Name> method;
  /// Name of the integration method
  std::shared_ptr<Name> steadystate;
  /// Block to be executed on error
  std::shared_ptr<StatementBlock> ifsolerr;
  /// token with location information
  std::shared_ptr<ModToken> token;
  /// symbol table for a block
  symtab::SymbolTable *symtab = nullptr;

public:
  /// \name Ctor & dtor
  /// \{

  explicit SolveBlock(Name *block_name, Name *method, Name *steadystate,
                      StatementBlock *ifsolerr);
  explicit SolveBlock(const std::shared_ptr<Name> &block_name,
                      const std::shared_ptr<Name> &method,
                      const std::shared_ptr<Name> &steadystate,
                      const std::shared_ptr<StatementBlock> &ifsolerr);
  SolveBlock(const SolveBlock &obj);

  virtual ~SolveBlock() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::SolveBlock
   * \return true as object is of type ast::SolveBlock
   */
  bool is_solve_block() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  SolveBlock *clone() const override { return new SolveBlock(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::SOLVE_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::SOLVE_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "SolveBlock"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "SolveBlock";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "SOLVE"
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "SOLVE"; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<SolveBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const SolveBlock>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return associated symbol table for the current ast node
   *
   * Only certain ast nodes (e.g. inherited from ast::Block) have associated
   * symbol table. These nodes have nmodl::symtab::SymbolTable as member
   * and it can be accessed using this method.
   *
   * \return pointer to the symbol table
   *
   * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
   */
  symtab::SymbolTable *get_symbol_table() const override { return symtab; }

  /**
   * \brief Getter for member variable \ref SolveBlock.block_name
   */
  const std::shared_ptr<Name> &get_block_name() const noexcept {
    return block_name;
  }

  /**
   * \brief Getter for member variable \ref SolveBlock.method
   */
  const std::shared_ptr<Name> &get_method() const noexcept { return method; }

  /**
   * \brief Getter for member variable \ref SolveBlock.steadystate
   */
  const std::shared_ptr<Name> &get_steadystate() const noexcept {
    return steadystate;
  }

  /**
   * \brief Getter for member variable \ref SolveBlock.ifsolerr
   */
  const std::shared_ptr<StatementBlock> &get_ifsolerr() const noexcept {
    return ifsolerr;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Set symbol table for the current ast node
   *
   * Top level, block scoped nodes store symbol table in the ast node.
   * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
   * for every node in the ast.
   *
   * \sa nmodl::visitor::SymtabVisitor
   */
  void set_symbol_table(symtab::SymbolTable *newsymtab) override {
    symtab = newsymtab;
  }

  /**
   * \brief Setter for member variable \ref SolveBlock.block_name (rvalue
   * reference)
   */
  void set_block_name(std::shared_ptr<Name> &&block_name);

  /**
   * \brief Setter for member variable \ref SolveBlock.block_name
   */
  void set_block_name(const std::shared_ptr<Name> &block_name);

  /**
   * \brief Setter for member variable \ref SolveBlock.method (rvalue reference)
   */
  void set_method(std::shared_ptr<Name> &&method);

  /**
   * \brief Setter for member variable \ref SolveBlock.method
   */
  void set_method(const std::shared_ptr<Name> &method);

  /**
   * \brief Setter for member variable \ref SolveBlock.steadystate (rvalue
   * reference)
   */
  void set_steadystate(std::shared_ptr<Name> &&steadystate);

  /**
   * \brief Setter for member variable \ref SolveBlock.steadystate
   */
  void set_steadystate(const std::shared_ptr<Name> &steadystate);

  /**
   * \brief Setter for member variable \ref SolveBlock.ifsolerr (rvalue
   * reference)
   */
  void set_ifsolerr(std::shared_ptr<StatementBlock> &&ifsolerr);

  /**
   * \brief Setter for member variable \ref SolveBlock.ifsolerr
   */
  void set_ifsolerr(const std::shared_ptr<StatementBlock> &ifsolerr);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_SOLVE_BLOCK_HPP
#ifndef NMODL_AST_BREAKPOINT_BLOCK_HPP
#define NMODL_AST_BREAKPOINT_BLOCK_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a `BREAKPOINT` block in NMODL
 *
 * The `BREAKPOINT` block is used to update current and conductance.
 * at each time step. Here is an example of `BEFORE` :
 *
 * \code{.mod}
 *     BREAKPOINT {
 *         SOLVE states METHOD cnexp
 *         gna = gnabar*m*m*m*h
 *         ina = gna*(v - ena)
 *         gk = gkbar*n*n*n*n
 *         ik = gk*(v - ek)
 *         il = gl*(v - el)
 *     }
 * \endcode
 *
 * \sa ast::DerivativeBlock ast::InitialBlock
 *
 */
class BreakpointBlock : public Block {
private:
  /// Block with statements vector
  std::shared_ptr<StatementBlock> statement_block;
  /// token with location information
  std::shared_ptr<ModToken> token;
  /// symbol table for a block
  symtab::SymbolTable *symtab = nullptr;

public:
  /// \name Ctor & dtor
  /// \{

  explicit BreakpointBlock(StatementBlock *statement_block);
  explicit BreakpointBlock(
      const std::shared_ptr<StatementBlock> &statement_block);
  BreakpointBlock(const BreakpointBlock &obj);

  virtual ~BreakpointBlock() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::BreakpointBlock
   * \return true as object is of type ast::BreakpointBlock
   */
  bool is_breakpoint_block() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  BreakpointBlock *clone() const override { return new BreakpointBlock(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::BREAKPOINT_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::BREAKPOINT_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "BreakpointBlock"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "BreakpointBlock";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "BREAKPOINT "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "BREAKPOINT "; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<BreakpointBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const BreakpointBlock>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return associated symbol table for the current ast node
   *
   * Only certain ast nodes (e.g. inherited from ast::Block) have associated
   * symbol table. These nodes have nmodl::symtab::SymbolTable as member
   * and it can be accessed using this method.
   *
   * \return pointer to the symbol table
   *
   * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
   */
  symtab::SymbolTable *get_symbol_table() const override { return symtab; }

  /**
   * \brief Getter for member variable \ref BreakpointBlock.statement_block
   */
  const std::shared_ptr<StatementBlock> &get_statement_block() const
      noexcept override {
    return statement_block;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Set symbol table for the current ast node
   *
   * Top level, block scoped nodes store symbol table in the ast node.
   * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
   * for every node in the ast.
   *
   * \sa nmodl::visitor::SymtabVisitor
   */
  void set_symbol_table(symtab::SymbolTable *newsymtab) override {
    symtab = newsymtab;
  }

  /**
   * \brief Setter for member variable \ref BreakpointBlock.statement_block
   * (rvalue reference)
   */
  void set_statement_block(std::shared_ptr<StatementBlock> &&statement_block);

  /**
   * \brief Setter for member variable \ref BreakpointBlock.statement_block
   */
  void
  set_statement_block(const std::shared_ptr<StatementBlock> &statement_block);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_BREAKPOINT_BLOCK_HPP
#ifndef NMODL_AST_TERMINAL_BLOCK_HPP
#define NMODL_AST_TERMINAL_BLOCK_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class TerminalBlock : public Block {
private:
  /// Block with statements vector
  std::shared_ptr<StatementBlock> statement_block;
  /// token with location information
  std::shared_ptr<ModToken> token;
  /// symbol table for a block
  symtab::SymbolTable *symtab = nullptr;

public:
  /// \name Ctor & dtor
  /// \{

  explicit TerminalBlock(StatementBlock *statement_block);
  explicit TerminalBlock(
      const std::shared_ptr<StatementBlock> &statement_block);
  TerminalBlock(const TerminalBlock &obj);

  virtual ~TerminalBlock() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::TerminalBlock
   * \return true as object is of type ast::TerminalBlock
   */
  bool is_terminal_block() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  TerminalBlock *clone() const override { return new TerminalBlock(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::TERMINAL_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::TERMINAL_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "TerminalBlock"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "TerminalBlock";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "TERMINAL "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "TERMINAL "; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<TerminalBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const TerminalBlock>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return associated symbol table for the current ast node
   *
   * Only certain ast nodes (e.g. inherited from ast::Block) have associated
   * symbol table. These nodes have nmodl::symtab::SymbolTable as member
   * and it can be accessed using this method.
   *
   * \return pointer to the symbol table
   *
   * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
   */
  symtab::SymbolTable *get_symbol_table() const override { return symtab; }

  /**
   * \brief Getter for member variable \ref TerminalBlock.statement_block
   */
  const std::shared_ptr<StatementBlock> &get_statement_block() const
      noexcept override {
    return statement_block;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Set symbol table for the current ast node
   *
   * Top level, block scoped nodes store symbol table in the ast node.
   * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
   * for every node in the ast.
   *
   * \sa nmodl::visitor::SymtabVisitor
   */
  void set_symbol_table(symtab::SymbolTable *newsymtab) override {
    symtab = newsymtab;
  }

  /**
   * \brief Setter for member variable \ref TerminalBlock.statement_block
   * (rvalue reference)
   */
  void set_statement_block(std::shared_ptr<StatementBlock> &&statement_block);

  /**
   * \brief Setter for member variable \ref TerminalBlock.statement_block
   */
  void
  set_statement_block(const std::shared_ptr<StatementBlock> &statement_block);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_TERMINAL_BLOCK_HPP
#ifndef NMODL_AST_BEFORE_BLOCK_HPP
#define NMODL_AST_BEFORE_BLOCK_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a `BEFORE` block in NMODL
 *
 *
 */
class BeforeBlock : public Block {
private:
  /// Block to be called before
  std::shared_ptr<BABlock> bablock;
  /// token with location information
  std::shared_ptr<ModToken> token;
  /// symbol table for a block
  symtab::SymbolTable *symtab = nullptr;

public:
  /// \name Ctor & dtor
  /// \{

  explicit BeforeBlock(BABlock *bablock);
  explicit BeforeBlock(const std::shared_ptr<BABlock> &bablock);
  BeforeBlock(const BeforeBlock &obj);

  virtual ~BeforeBlock() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::BeforeBlock
   * \return true as object is of type ast::BeforeBlock
   */
  bool is_before_block() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  BeforeBlock *clone() const override { return new BeforeBlock(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::BEFORE_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::BEFORE_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "BeforeBlock"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "BeforeBlock";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "BEFORE "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "BEFORE "; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<BeforeBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const BeforeBlock>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return associated symbol table for the current ast node
   *
   * Only certain ast nodes (e.g. inherited from ast::Block) have associated
   * symbol table. These nodes have nmodl::symtab::SymbolTable as member
   * and it can be accessed using this method.
   *
   * \return pointer to the symbol table
   *
   * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
   */
  symtab::SymbolTable *get_symbol_table() const override { return symtab; }

  /**
   * \brief Getter for member variable \ref BeforeBlock.bablock
   */
  const std::shared_ptr<BABlock> &get_bablock() const noexcept {
    return bablock;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Set symbol table for the current ast node
   *
   * Top level, block scoped nodes store symbol table in the ast node.
   * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
   * for every node in the ast.
   *
   * \sa nmodl::visitor::SymtabVisitor
   */
  void set_symbol_table(symtab::SymbolTable *newsymtab) override {
    symtab = newsymtab;
  }

  /**
   * \brief Setter for member variable \ref BeforeBlock.bablock (rvalue
   * reference)
   */
  void set_bablock(std::shared_ptr<BABlock> &&bablock);

  /**
   * \brief Setter for member variable \ref BeforeBlock.bablock
   */
  void set_bablock(const std::shared_ptr<BABlock> &bablock);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_BEFORE_BLOCK_HPP
#ifndef NMODL_AST_AFTER_BLOCK_HPP
#define NMODL_AST_AFTER_BLOCK_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a `AFTER` block in NMODL
 *
 * This represents a block to be executed before another block.
 * Here is an example of `BEFORE` :
 *
 * \code{.mod}
 *     BEFORE STEP {
 *       if (mode==1) {
 *         if (ica<imax) {
 *           imax = ica
 *           timax = t
 *         }
 *       }
 *     }
 * \endcode
 *
 */
class AfterBlock : public Block {
private:
  /// Block to be called after
  std::shared_ptr<BABlock> bablock;
  /// token with location information
  std::shared_ptr<ModToken> token;
  /// symbol table for a block
  symtab::SymbolTable *symtab = nullptr;

public:
  /// \name Ctor & dtor
  /// \{

  explicit AfterBlock(BABlock *bablock);
  explicit AfterBlock(const std::shared_ptr<BABlock> &bablock);
  AfterBlock(const AfterBlock &obj);

  virtual ~AfterBlock() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::AfterBlock
   * \return true as object is of type ast::AfterBlock
   */
  bool is_after_block() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  AfterBlock *clone() const override { return new AfterBlock(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::AFTER_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::AFTER_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "AfterBlock"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "AfterBlock";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "AFTER "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "AFTER "; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<AfterBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const AfterBlock>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return associated symbol table for the current ast node
   *
   * Only certain ast nodes (e.g. inherited from ast::Block) have associated
   * symbol table. These nodes have nmodl::symtab::SymbolTable as member
   * and it can be accessed using this method.
   *
   * \return pointer to the symbol table
   *
   * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
   */
  symtab::SymbolTable *get_symbol_table() const override { return symtab; }

  /**
   * \brief Getter for member variable \ref AfterBlock.bablock
   */
  const std::shared_ptr<BABlock> &get_bablock() const noexcept {
    return bablock;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Set symbol table for the current ast node
   *
   * Top level, block scoped nodes store symbol table in the ast node.
   * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
   * for every node in the ast.
   *
   * \sa nmodl::visitor::SymtabVisitor
   */
  void set_symbol_table(symtab::SymbolTable *newsymtab) override {
    symtab = newsymtab;
  }

  /**
   * \brief Setter for member variable \ref AfterBlock.bablock (rvalue
   * reference)
   */
  void set_bablock(std::shared_ptr<BABlock> &&bablock);

  /**
   * \brief Setter for member variable \ref AfterBlock.bablock
   */
  void set_bablock(const std::shared_ptr<BABlock> &bablock);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_AFTER_BLOCK_HPP
#ifndef NMODL_AST_BA_BLOCK_HPP
#define NMODL_AST_BA_BLOCK_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a block to be executed before or after another block
 *
 * This represents a block to be executed before or after another
 * block in NMODL. See ast::BeforeBlock and ast::AfterBlock for usage.
 *
 */
class BABlock : public Block {
private:
  /// Type of NMODL block
  std::shared_ptr<BABlockType> type;
  /// Block with statements vector
  std::shared_ptr<StatementBlock> statement_block;
  /// token with location information
  std::shared_ptr<ModToken> token;
  /// symbol table for a block
  symtab::SymbolTable *symtab = nullptr;

public:
  /// \name Ctor & dtor
  /// \{

  explicit BABlock(BABlockType *type, StatementBlock *statement_block);
  explicit BABlock(const std::shared_ptr<BABlockType> &type,
                   const std::shared_ptr<StatementBlock> &statement_block);
  BABlock(const BABlock &obj);

  virtual ~BABlock() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::BABlock
   * \return true as object is of type ast::BABlock
   */
  bool is_ba_block() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  BABlock *clone() const override { return new BABlock(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::BA_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::BA_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "BABlock"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override { return "BABlock"; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<BABlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const BABlock>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return associated symbol table for the current ast node
   *
   * Only certain ast nodes (e.g. inherited from ast::Block) have associated
   * symbol table. These nodes have nmodl::symtab::SymbolTable as member
   * and it can be accessed using this method.
   *
   * \return pointer to the symbol table
   *
   * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
   */
  symtab::SymbolTable *get_symbol_table() const override { return symtab; }

  /**
   * \brief Getter for member variable \ref BABlock.type
   */
  const std::shared_ptr<BABlockType> &get_type() const noexcept { return type; }

  /**
   * \brief Getter for member variable \ref BABlock.statement_block
   */
  const std::shared_ptr<StatementBlock> &get_statement_block() const
      noexcept override {
    return statement_block;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Set symbol table for the current ast node
   *
   * Top level, block scoped nodes store symbol table in the ast node.
   * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
   * for every node in the ast.
   *
   * \sa nmodl::visitor::SymtabVisitor
   */
  void set_symbol_table(symtab::SymbolTable *newsymtab) override {
    symtab = newsymtab;
  }

  /**
   * \brief Setter for member variable \ref BABlock.type (rvalue reference)
   */
  void set_type(std::shared_ptr<BABlockType> &&type);

  /**
   * \brief Setter for member variable \ref BABlock.type
   */
  void set_type(const std::shared_ptr<BABlockType> &type);

  /**
   * \brief Setter for member variable \ref BABlock.statement_block (rvalue
   * reference)
   */
  void set_statement_block(std::shared_ptr<StatementBlock> &&statement_block);

  /**
   * \brief Setter for member variable \ref BABlock.statement_block
   */
  void
  set_statement_block(const std::shared_ptr<StatementBlock> &statement_block);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_BA_BLOCK_HPP
#ifndef NMODL_AST_FOR_NETCON_HPP
#define NMODL_AST_FOR_NETCON_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class ForNetcon : public Block {
private:
  /// Arguments to the for netcon block
  ArgumentVector parameters;
  /// Block with statements vector
  std::shared_ptr<StatementBlock> statement_block;
  /// token with location information
  std::shared_ptr<ModToken> token;
  /// symbol table for a block
  symtab::SymbolTable *symtab = nullptr;

public:
  /// \name Ctor & dtor
  /// \{

  explicit ForNetcon(ArgumentVector parameters,
                     StatementBlock *statement_block);
  explicit ForNetcon(const ArgumentVector &parameters,
                     const std::shared_ptr<StatementBlock> &statement_block);
  ForNetcon(const ForNetcon &obj);

  virtual ~ForNetcon() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::ForNetcon
   * \return true as object is of type ast::ForNetcon
   */
  bool is_for_netcon() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  ForNetcon *clone() const override { return new ForNetcon(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::FOR_NETCON
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::FOR_NETCON;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "ForNetcon"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "ForNetcon";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "FOR_NETCONS "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override {
    return "FOR_NETCONS ";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<ForNetcon>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const ForNetcon>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return associated symbol table for the current ast node
   *
   * Only certain ast nodes (e.g. inherited from ast::Block) have associated
   * symbol table. These nodes have nmodl::symtab::SymbolTable as member
   * and it can be accessed using this method.
   *
   * \return pointer to the symbol table
   *
   * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
   */
  symtab::SymbolTable *get_symbol_table() const override { return symtab; }

  /**
   * \brief Getter for member variable \ref ForNetcon.parameters
   */
  const ArgumentVector &get_parameters() const noexcept override {
    return parameters;
  }

  /**
   * \brief Getter for member variable \ref ForNetcon.statement_block
   */
  const std::shared_ptr<StatementBlock> &get_statement_block() const
      noexcept override {
    return statement_block;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Set symbol table for the current ast node
   *
   * Top level, block scoped nodes store symbol table in the ast node.
   * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
   * for every node in the ast.
   *
   * \sa nmodl::visitor::SymtabVisitor
   */
  void set_symbol_table(symtab::SymbolTable *newsymtab) override {
    symtab = newsymtab;
  }

  /**
   * \brief Setter for member variable \ref ForNetcon.parameters (rvalue
   * reference)
   */
  void set_parameters(ArgumentVector &&parameters);

  /**
   * \brief Setter for member variable \ref ForNetcon.parameters
   */
  void set_parameters(const ArgumentVector &parameters);

  /**
   * \brief Setter for member variable \ref ForNetcon.statement_block (rvalue
   * reference)
   */
  void set_statement_block(std::shared_ptr<StatementBlock> &&statement_block);

  /**
   * \brief Setter for member variable \ref ForNetcon.statement_block
   */
  void
  set_statement_block(const std::shared_ptr<StatementBlock> &statement_block);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_FOR_NETCON_HPP
#ifndef NMODL_AST_KINETIC_BLOCK_HPP
#define NMODL_AST_KINETIC_BLOCK_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class KineticBlock : public Block {
private:
  /// Name of the kinetic block
  std::shared_ptr<Name> name;
  /// Solve for specification (TODO)
  NameVector solvefor;
  /// Block with statements vector
  std::shared_ptr<StatementBlock> statement_block;
  /// token with location information
  std::shared_ptr<ModToken> token;
  /// symbol table for a block
  symtab::SymbolTable *symtab = nullptr;

public:
  /// \name Ctor & dtor
  /// \{

  explicit KineticBlock(Name *name, NameVector solvefor,
                        StatementBlock *statement_block);
  explicit KineticBlock(const std::shared_ptr<Name> &name,
                        const NameVector &solvefor,
                        const std::shared_ptr<StatementBlock> &statement_block);
  KineticBlock(const KineticBlock &obj);

  virtual ~KineticBlock() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::KineticBlock
   * \return true as object is of type ast::KineticBlock
   */
  bool is_kinetic_block() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  KineticBlock *clone() const override { return new KineticBlock(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::KINETIC_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::KINETIC_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "KineticBlock"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "KineticBlock";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "KINETIC "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "KINETIC "; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<KineticBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const KineticBlock>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return associated symbol table for the current ast node
   *
   * Only certain ast nodes (e.g. inherited from ast::Block) have associated
   * symbol table. These nodes have nmodl::symtab::SymbolTable as member
   * and it can be accessed using this method.
   *
   * \return pointer to the symbol table
   *
   * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
   */
  symtab::SymbolTable *get_symbol_table() const override { return symtab; }

  /**
   * \brief Return name of the node
   *
   * Some ast nodes have a member marked designated as node name. For example,
   * in case of this ast::Name has name designated as a
   * node name.
   *
   * @return name of the node as std::string
   *
   * \sa Ast::get_node_type_name
   */
  std::string get_node_name() const override;

  /**
   * \brief Getter for member variable \ref KineticBlock.name
   */
  const std::shared_ptr<Name> &get_name() const noexcept { return name; }

  /**
   * \brief Getter for member variable \ref KineticBlock.solvefor
   */
  const NameVector &get_solvefor() const noexcept { return solvefor; }

  /**
   * \brief Getter for member variable \ref KineticBlock.statement_block
   */
  const std::shared_ptr<StatementBlock> &get_statement_block() const
      noexcept override {
    return statement_block;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Set symbol table for the current ast node
   *
   * Top level, block scoped nodes store symbol table in the ast node.
   * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
   * for every node in the ast.
   *
   * \sa nmodl::visitor::SymtabVisitor
   */
  void set_symbol_table(symtab::SymbolTable *newsymtab) override {
    symtab = newsymtab;
  }

  /**
   * \brief Setter for member variable \ref KineticBlock.name (rvalue reference)
   */
  void set_name(std::shared_ptr<Name> &&name);

  /**
   * \brief Setter for member variable \ref KineticBlock.name
   */
  void set_name(const std::shared_ptr<Name> &name);

  /**
   * \brief Setter for member variable \ref KineticBlock.solvefor (rvalue
   * reference)
   */
  void set_solvefor(NameVector &&solvefor);

  /**
   * \brief Setter for member variable \ref KineticBlock.solvefor
   */
  void set_solvefor(const NameVector &solvefor);

  /**
   * \brief Setter for member variable \ref KineticBlock.statement_block (rvalue
   * reference)
   */
  void set_statement_block(std::shared_ptr<StatementBlock> &&statement_block);

  /**
   * \brief Setter for member variable \ref KineticBlock.statement_block
   */
  void
  set_statement_block(const std::shared_ptr<StatementBlock> &statement_block);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_KINETIC_BLOCK_HPP
#ifndef NMODL_AST_MATCH_BLOCK_HPP
#define NMODL_AST_MATCH_BLOCK_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class MatchBlock : public Block {
private:
  /// Vector of match statements
  MatchVector matchs;
  /// token with location information
  std::shared_ptr<ModToken> token;
  /// symbol table for a block
  symtab::SymbolTable *symtab = nullptr;

public:
  /// \name Ctor & dtor
  /// \{

  explicit MatchBlock(MatchVector matchs);
  MatchBlock(const MatchBlock &obj);

  virtual ~MatchBlock() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::MatchBlock
   * \return true as object is of type ast::MatchBlock
   */
  bool is_match_block() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  MatchBlock *clone() const override { return new MatchBlock(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::MATCH_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::MATCH_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "MatchBlock"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "MatchBlock";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "MATCH"
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "MATCH"; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<MatchBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const MatchBlock>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return associated symbol table for the current ast node
   *
   * Only certain ast nodes (e.g. inherited from ast::Block) have associated
   * symbol table. These nodes have nmodl::symtab::SymbolTable as member
   * and it can be accessed using this method.
   *
   * \return pointer to the symbol table
   *
   * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
   */
  symtab::SymbolTable *get_symbol_table() const override { return symtab; }

  /**
   * \brief Getter for member variable \ref MatchBlock.matchs
   */
  const MatchVector &get_matchs() const noexcept { return matchs; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Set symbol table for the current ast node
   *
   * Top level, block scoped nodes store symbol table in the ast node.
   * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
   * for every node in the ast.
   *
   * \sa nmodl::visitor::SymtabVisitor
   */
  void set_symbol_table(symtab::SymbolTable *newsymtab) override {
    symtab = newsymtab;
  }

  /**
   * \brief Setter for member variable \ref MatchBlock.matchs (rvalue reference)
   */
  void set_matchs(MatchVector &&matchs);

  /**
   * \brief Setter for member variable \ref MatchBlock.matchs
   */
  void set_matchs(const MatchVector &matchs);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_MATCH_BLOCK_HPP
#ifndef NMODL_AST_UNIT_BLOCK_HPP
#define NMODL_AST_UNIT_BLOCK_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class UnitBlock : public Block {
private:
  /// Vector of unit statements
  ExpressionVector definitions;
  /// token with location information
  std::shared_ptr<ModToken> token;
  /// symbol table for a block
  symtab::SymbolTable *symtab = nullptr;

public:
  /// \name Ctor & dtor
  /// \{

  explicit UnitBlock(ExpressionVector definitions);
  UnitBlock(const UnitBlock &obj);

  virtual ~UnitBlock() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::UnitBlock
   * \return true as object is of type ast::UnitBlock
   */
  bool is_unit_block() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  UnitBlock *clone() const override { return new UnitBlock(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::UNIT_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::UNIT_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "UnitBlock"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "UnitBlock";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "UNITS "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "UNITS "; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<UnitBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const UnitBlock>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return associated symbol table for the current ast node
   *
   * Only certain ast nodes (e.g. inherited from ast::Block) have associated
   * symbol table. These nodes have nmodl::symtab::SymbolTable as member
   * and it can be accessed using this method.
   *
   * \return pointer to the symbol table
   *
   * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
   */
  symtab::SymbolTable *get_symbol_table() const override { return symtab; }

  /**
   * \brief Getter for member variable \ref UnitBlock.definitions
   */
  const ExpressionVector &get_definitions() const noexcept {
    return definitions;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Set symbol table for the current ast node
   *
   * Top level, block scoped nodes store symbol table in the ast node.
   * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
   * for every node in the ast.
   *
   * \sa nmodl::visitor::SymtabVisitor
   */
  void set_symbol_table(symtab::SymbolTable *newsymtab) override {
    symtab = newsymtab;
  }

  /**
   * \brief Setter for member variable \ref UnitBlock.definitions (rvalue
   * reference)
   */
  void set_definitions(ExpressionVector &&definitions);

  /**
   * \brief Setter for member variable \ref UnitBlock.definitions
   */
  void set_definitions(const ExpressionVector &definitions);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_UNIT_BLOCK_HPP
#ifndef NMODL_AST_CONSTANT_BLOCK_HPP
#define NMODL_AST_CONSTANT_BLOCK_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represent `CONSTANT` block in the mod file
 *
 * Here is an example of `CONSTANT` block in mod file:
 *
 * \code{.mod}
 *     CONSTANT {
 *         q10 = 3
 *
 *         cvm = 28.9 (mV)
 *         ckm = 6.2 (mV)
 *         ctm = 0.000505 (s)
 *     }
 * \endcode
 *
 */
class ConstantBlock : public Block {
private:
  /// Vector of constant statements
  ConstantStatementVector statements;
  /// token with location information
  std::shared_ptr<ModToken> token;
  /// symbol table for a block
  symtab::SymbolTable *symtab = nullptr;

public:
  /// \name Ctor & dtor
  /// \{

  explicit ConstantBlock(ConstantStatementVector statements);
  ConstantBlock(const ConstantBlock &obj);

  virtual ~ConstantBlock() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::ConstantBlock
   * \return true as object is of type ast::ConstantBlock
   */
  bool is_constant_block() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  ConstantBlock *clone() const override { return new ConstantBlock(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::CONSTANT_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::CONSTANT_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "ConstantBlock"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "ConstantBlock";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "CONSTANT "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "CONSTANT "; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<ConstantBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const ConstantBlock>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return associated symbol table for the current ast node
   *
   * Only certain ast nodes (e.g. inherited from ast::Block) have associated
   * symbol table. These nodes have nmodl::symtab::SymbolTable as member
   * and it can be accessed using this method.
   *
   * \return pointer to the symbol table
   *
   * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
   */
  symtab::SymbolTable *get_symbol_table() const override { return symtab; }

  /**
   * \brief Getter for member variable \ref ConstantBlock.statements
   */
  const ConstantStatementVector &get_statements() const noexcept {
    return statements;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Set symbol table for the current ast node
   *
   * Top level, block scoped nodes store symbol table in the ast node.
   * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
   * for every node in the ast.
   *
   * \sa nmodl::visitor::SymtabVisitor
   */
  void set_symbol_table(symtab::SymbolTable *newsymtab) override {
    symtab = newsymtab;
  }

  /**
   * \brief Setter for member variable \ref ConstantBlock.statements (rvalue
   * reference)
   */
  void set_statements(ConstantStatementVector &&statements);

  /**
   * \brief Setter for member variable \ref ConstantBlock.statements
   */
  void set_statements(const ConstantStatementVector &statements);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_CONSTANT_BLOCK_HPP
#ifndef NMODL_AST_NEURON_BLOCK_HPP
#define NMODL_AST_NEURON_BLOCK_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represent `NEURON` block in the mod file
 *
 * The keyword `NEURON` introduces a special block which contains statements
 * that tell NMODL how to organize the variables for access at the NEURON user
 * level. Here is an example of `NEURON` block from `HH` channel:
 *
 * \code{.mod}
 *     NEURON {
 *             SUFFIX hh
 *             USEION na READ ena WRITE ina
 *             USEION k READ ek WRITE ik
 *             NONSPECIFIC_CURRENT il
 *             RANGE gnabar, gkbar, gl, el, gna, gk
 *             RANGE minf, hinf, ninf, mtau, htau, ntau
 *             THREADSAFE
 *     }
 * \endcode
 *
 */
class NeuronBlock : public Block {
private:
  /// Block with statements vector
  std::shared_ptr<StatementBlock> statement_block;
  /// token with location information
  std::shared_ptr<ModToken> token;
  /// symbol table for a block
  symtab::SymbolTable *symtab = nullptr;

public:
  /// \name Ctor & dtor
  /// \{

  explicit NeuronBlock(StatementBlock *statement_block);
  explicit NeuronBlock(const std::shared_ptr<StatementBlock> &statement_block);
  NeuronBlock(const NeuronBlock &obj);

  virtual ~NeuronBlock() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::NeuronBlock
   * \return true as object is of type ast::NeuronBlock
   */
  bool is_neuron_block() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  NeuronBlock *clone() const override { return new NeuronBlock(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::NEURON_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::NEURON_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "NeuronBlock"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "NeuronBlock";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "NEURON "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "NEURON "; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<NeuronBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const NeuronBlock>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return associated symbol table for the current ast node
   *
   * Only certain ast nodes (e.g. inherited from ast::Block) have associated
   * symbol table. These nodes have nmodl::symtab::SymbolTable as member
   * and it can be accessed using this method.
   *
   * \return pointer to the symbol table
   *
   * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
   */
  symtab::SymbolTable *get_symbol_table() const override { return symtab; }

  /**
   * \brief Getter for member variable \ref NeuronBlock.statement_block
   */
  const std::shared_ptr<StatementBlock> &get_statement_block() const
      noexcept override {
    return statement_block;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Set symbol table for the current ast node
   *
   * Top level, block scoped nodes store symbol table in the ast node.
   * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
   * for every node in the ast.
   *
   * \sa nmodl::visitor::SymtabVisitor
   */
  void set_symbol_table(symtab::SymbolTable *newsymtab) override {
    symtab = newsymtab;
  }

  /**
   * \brief Setter for member variable \ref NeuronBlock.statement_block (rvalue
   * reference)
   */
  void set_statement_block(std::shared_ptr<StatementBlock> &&statement_block);

  /**
   * \brief Setter for member variable \ref NeuronBlock.statement_block
   */
  void
  set_statement_block(const std::shared_ptr<StatementBlock> &statement_block);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_NEURON_BLOCK_HPP
#ifndef NMODL_AST_UNIT_HPP
#define NMODL_AST_UNIT_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class Unit : public Expression {
private:
  /// TODO
  std::shared_ptr<String> name;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit Unit(String *name);
  explicit Unit(const std::shared_ptr<String> &name);
  Unit(const Unit &obj);

  virtual ~Unit() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::Unit
   * \return true as object is of type ast::Unit
   */
  bool is_unit() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  Unit *clone() const override { return new Unit(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::UNIT
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::UNIT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Unit"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override { return "Unit"; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Unit>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Unit>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return name of the node
   *
   * Some ast nodes have a member marked designated as node name. For example,
   * in case of this ast::String has name designated as a
   * node name.
   *
   * @return name of the node as std::string
   *
   * \sa Ast::get_node_type_name
   */
  std::string get_node_name() const override;

  /**
   * \brief Getter for member variable \ref Unit.name
   */
  const std::shared_ptr<String> &get_name() const noexcept { return name; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref Unit.name (rvalue reference)
   */
  void set_name(std::shared_ptr<String> &&name);

  /**
   * \brief Setter for member variable \ref Unit.name
   */
  void set_name(const std::shared_ptr<String> &name);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_UNIT_HPP
#ifndef NMODL_AST_DOUBLE_UNIT_HPP
#define NMODL_AST_DOUBLE_UNIT_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class DoubleUnit : public Expression {
private:
  /// TODO
  std::shared_ptr<Double> value;
  /// TODO
  std::shared_ptr<Unit> unit;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit DoubleUnit(Double *value, Unit *unit);
  explicit DoubleUnit(const std::shared_ptr<Double> &value,
                      const std::shared_ptr<Unit> &unit);
  DoubleUnit(const DoubleUnit &obj);

  virtual ~DoubleUnit() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::DoubleUnit
   * \return true as object is of type ast::DoubleUnit
   */
  bool is_double_unit() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  DoubleUnit *clone() const override { return new DoubleUnit(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::DOUBLE_UNIT
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::DOUBLE_UNIT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "DoubleUnit"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "DoubleUnit";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<DoubleUnit>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const DoubleUnit>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref DoubleUnit.value
   */
  const std::shared_ptr<Double> &get_value() const noexcept { return value; }

  /**
   * \brief Getter for member variable \ref DoubleUnit.unit
   */
  const std::shared_ptr<Unit> &get_unit() const noexcept { return unit; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref DoubleUnit.value (rvalue reference)
   */
  void set_value(std::shared_ptr<Double> &&value);

  /**
   * \brief Setter for member variable \ref DoubleUnit.value
   */
  void set_value(const std::shared_ptr<Double> &value);

  /**
   * \brief Setter for member variable \ref DoubleUnit.unit (rvalue reference)
   */
  void set_unit(std::shared_ptr<Unit> &&unit);

  /**
   * \brief Setter for member variable \ref DoubleUnit.unit
   */
  void set_unit(const std::shared_ptr<Unit> &unit);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_DOUBLE_UNIT_HPP
#ifndef NMODL_AST_LOCAL_VAR_HPP
#define NMODL_AST_LOCAL_VAR_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class LocalVar : public Expression {
private:
  /// TODO
  std::shared_ptr<Identifier> name;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit LocalVar(Identifier *name);
  explicit LocalVar(const std::shared_ptr<Identifier> &name);
  LocalVar(const LocalVar &obj);

  virtual ~LocalVar() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::LocalVar
   * \return true as object is of type ast::LocalVar
   */
  bool is_local_var() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  LocalVar *clone() const override { return new LocalVar(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::LOCAL_VAR
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::LOCAL_VAR;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "LocalVar"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "LocalVar";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<LocalVar>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const LocalVar>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return name of the node
   *
   * Some ast nodes have a member marked designated as node name. For example,
   * in case of this ast::Identifier has name designated as a
   * node name.
   *
   * @return name of the node as std::string
   *
   * \sa Ast::get_node_type_name
   */
  std::string get_node_name() const override;

  /**
   * \brief Getter for member variable \ref LocalVar.name
   */
  const std::shared_ptr<Identifier> &get_name() const noexcept { return name; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref LocalVar.name (rvalue reference)
   */
  void set_name(std::shared_ptr<Identifier> &&name);

  /**
   * \brief Setter for member variable \ref LocalVar.name
   */
  void set_name(const std::shared_ptr<Identifier> &name);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_LOCAL_VAR_HPP
#ifndef NMODL_AST_LIMITS_HPP
#define NMODL_AST_LIMITS_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class Limits : public Expression {
private:
  /// TODO
  std::shared_ptr<Double> min;
  /// TODO
  std::shared_ptr<Double> max;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit Limits(Double *min, Double *max);
  explicit Limits(const std::shared_ptr<Double> &min,
                  const std::shared_ptr<Double> &max);
  Limits(const Limits &obj);

  virtual ~Limits() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::Limits
   * \return true as object is of type ast::Limits
   */
  bool is_limits() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  Limits *clone() const override { return new Limits(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::LIMITS
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::LIMITS;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Limits"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override { return "Limits"; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Limits>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Limits>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref Limits.min
   */
  const std::shared_ptr<Double> &get_min() const noexcept { return min; }

  /**
   * \brief Getter for member variable \ref Limits.max
   */
  const std::shared_ptr<Double> &get_max() const noexcept { return max; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref Limits.min (rvalue reference)
   */
  void set_min(std::shared_ptr<Double> &&min);

  /**
   * \brief Setter for member variable \ref Limits.min
   */
  void set_min(const std::shared_ptr<Double> &min);

  /**
   * \brief Setter for member variable \ref Limits.max (rvalue reference)
   */
  void set_max(std::shared_ptr<Double> &&max);

  /**
   * \brief Setter for member variable \ref Limits.max
   */
  void set_max(const std::shared_ptr<Double> &max);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_LIMITS_HPP
#ifndef NMODL_AST_NUMBER_RANGE_HPP
#define NMODL_AST_NUMBER_RANGE_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class NumberRange : public Expression {
private:
  /// TODO
  std::shared_ptr<Number> min;
  /// TODO
  std::shared_ptr<Number> max;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit NumberRange(Number *min, Number *max);
  explicit NumberRange(const std::shared_ptr<Number> &min,
                       const std::shared_ptr<Number> &max);
  NumberRange(const NumberRange &obj);

  virtual ~NumberRange() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::NumberRange
   * \return true as object is of type ast::NumberRange
   */
  bool is_number_range() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  NumberRange *clone() const override { return new NumberRange(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::NUMBER_RANGE
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::NUMBER_RANGE;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "NumberRange"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "NumberRange";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<NumberRange>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const NumberRange>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref NumberRange.min
   */
  const std::shared_ptr<Number> &get_min() const noexcept { return min; }

  /**
   * \brief Getter for member variable \ref NumberRange.max
   */
  const std::shared_ptr<Number> &get_max() const noexcept { return max; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref NumberRange.min (rvalue reference)
   */
  void set_min(std::shared_ptr<Number> &&min);

  /**
   * \brief Setter for member variable \ref NumberRange.min
   */
  void set_min(const std::shared_ptr<Number> &min);

  /**
   * \brief Setter for member variable \ref NumberRange.max (rvalue reference)
   */
  void set_max(std::shared_ptr<Number> &&max);

  /**
   * \brief Setter for member variable \ref NumberRange.max
   */
  void set_max(const std::shared_ptr<Number> &max);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_NUMBER_RANGE_HPP
#ifndef NMODL_AST_PLOT_VAR_HPP
#define NMODL_AST_PLOT_VAR_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class PlotVar : public Expression {
private:
  /// TODO
  std::shared_ptr<Identifier> name;
  /// TODO
  std::shared_ptr<Integer> index;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit PlotVar(Identifier *name, Integer *index);
  explicit PlotVar(const std::shared_ptr<Identifier> &name,
                   const std::shared_ptr<Integer> &index);
  PlotVar(const PlotVar &obj);

  virtual ~PlotVar() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::PlotVar
   * \return true as object is of type ast::PlotVar
   */
  bool is_plot_var() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  PlotVar *clone() const override { return new PlotVar(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::PLOT_VAR
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::PLOT_VAR;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "PlotVar"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override { return "PlotVar"; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<PlotVar>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const PlotVar>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref PlotVar.name
   */
  const std::shared_ptr<Identifier> &get_name() const noexcept { return name; }

  /**
   * \brief Getter for member variable \ref PlotVar.index
   */
  const std::shared_ptr<Integer> &get_index() const noexcept { return index; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref PlotVar.name (rvalue reference)
   */
  void set_name(std::shared_ptr<Identifier> &&name);

  /**
   * \brief Setter for member variable \ref PlotVar.name
   */
  void set_name(const std::shared_ptr<Identifier> &name);

  /**
   * \brief Setter for member variable \ref PlotVar.index (rvalue reference)
   */
  void set_index(std::shared_ptr<Integer> &&index);

  /**
   * \brief Setter for member variable \ref PlotVar.index
   */
  void set_index(const std::shared_ptr<Integer> &index);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_PLOT_VAR_HPP
#ifndef NMODL_AST_CONSTANT_VAR_HPP
#define NMODL_AST_CONSTANT_VAR_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a variable in the ast::ConstantBlock
 *
 *
 */
class ConstantVar : public Expression {
private:
  /// Name of the variable
  std::shared_ptr<Name> name;
  /// Value of the constant
  std::shared_ptr<Number> value;
  /// Unit for the variable
  std::shared_ptr<Unit> unit;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit ConstantVar(Name *name, Number *value, Unit *unit);
  explicit ConstantVar(const std::shared_ptr<Name> &name,
                       const std::shared_ptr<Number> &value,
                       const std::shared_ptr<Unit> &unit);
  ConstantVar(const ConstantVar &obj);

  virtual ~ConstantVar() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::ConstantVar
   * \return true as object is of type ast::ConstantVar
   */
  bool is_constant_var() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  ConstantVar *clone() const override { return new ConstantVar(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::CONSTANT_VAR
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::CONSTANT_VAR;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "ConstantVar"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "ConstantVar";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<ConstantVar>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const ConstantVar>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return name of the node
   *
   * Some ast nodes have a member marked designated as node name. For example,
   * in case of this ast::Name has name designated as a
   * node name.
   *
   * @return name of the node as std::string
   *
   * \sa Ast::get_node_type_name
   */
  std::string get_node_name() const override;

  /**
   * \brief Getter for member variable \ref ConstantVar.name
   */
  const std::shared_ptr<Name> &get_name() const noexcept { return name; }

  /**
   * \brief Getter for member variable \ref ConstantVar.value
   */
  const std::shared_ptr<Number> &get_value() const noexcept { return value; }

  /**
   * \brief Getter for member variable \ref ConstantVar.unit
   */
  const std::shared_ptr<Unit> &get_unit() const noexcept { return unit; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref ConstantVar.name (rvalue reference)
   */
  void set_name(std::shared_ptr<Name> &&name);

  /**
   * \brief Setter for member variable \ref ConstantVar.name
   */
  void set_name(const std::shared_ptr<Name> &name);

  /**
   * \brief Setter for member variable \ref ConstantVar.value (rvalue reference)
   */
  void set_value(std::shared_ptr<Number> &&value);

  /**
   * \brief Setter for member variable \ref ConstantVar.value
   */
  void set_value(const std::shared_ptr<Number> &value);

  /**
   * \brief Setter for member variable \ref ConstantVar.unit (rvalue reference)
   */
  void set_unit(std::shared_ptr<Unit> &&unit);

  /**
   * \brief Setter for member variable \ref ConstantVar.unit
   */
  void set_unit(const std::shared_ptr<Unit> &unit);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_CONSTANT_VAR_HPP
#ifndef NMODL_AST_BINARY_OPERATOR_HPP
#define NMODL_AST_BINARY_OPERATOR_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Operator used in ast::BinaryExpression
 *
 *
 */
class BinaryOperator : public Expression {
private:
  /// Operator
  BinaryOp value;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit BinaryOperator(BinaryOp value);
  BinaryOperator(const BinaryOperator &obj);

  BinaryOperator() = default;

  virtual ~BinaryOperator() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::BinaryOperator
   * \return true as object is of type ast::BinaryOperator
   */
  bool is_binary_operator() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  BinaryOperator *clone() const override { return new BinaryOperator(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::BINARY_OPERATOR
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::BINARY_OPERATOR;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "BinaryOperator"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "BinaryOperator";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<BinaryOperator>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const BinaryOperator>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref BinaryOperator.value
   */
  BinaryOp get_value() const noexcept { return value; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref BinaryOperator.value
   */
  void set_value(BinaryOp value);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

  /**
   * \brief Return enum value in string form
   *
   * Enum variables (e.g. ast::BinaryOp, ast::UnitStateType) have
   * string representation when they are converted from AST back to
   * NMODL. This method is used to return corresponding string representation.
   */
  std::string eval() const { return BinaryOpNames[value]; }

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_BINARY_OPERATOR_HPP
#ifndef NMODL_AST_UNARY_OPERATOR_HPP
#define NMODL_AST_UNARY_OPERATOR_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class UnaryOperator : public Expression {
private:
  /// TODO
  UnaryOp value;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit UnaryOperator(UnaryOp value);
  UnaryOperator(const UnaryOperator &obj);

  UnaryOperator() = default;

  virtual ~UnaryOperator() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::UnaryOperator
   * \return true as object is of type ast::UnaryOperator
   */
  bool is_unary_operator() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  UnaryOperator *clone() const override { return new UnaryOperator(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::UNARY_OPERATOR
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::UNARY_OPERATOR;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "UnaryOperator"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "UnaryOperator";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<UnaryOperator>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const UnaryOperator>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref UnaryOperator.value
   */
  UnaryOp get_value() const noexcept { return value; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref UnaryOperator.value
   */
  void set_value(UnaryOp value);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

  /**
   * \brief Return enum value in string form
   *
   * Enum variables (e.g. ast::BinaryOp, ast::UnitStateType) have
   * string representation when they are converted from AST back to
   * NMODL. This method is used to return corresponding string representation.
   */
  std::string eval() const { return UnaryOpNames[value]; }

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_UNARY_OPERATOR_HPP
#ifndef NMODL_AST_REACTION_OPERATOR_HPP
#define NMODL_AST_REACTION_OPERATOR_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class ReactionOperator : public Expression {
private:
  /// TODO
  ReactionOp value;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit ReactionOperator(ReactionOp value);
  ReactionOperator(const ReactionOperator &obj);

  ReactionOperator() = default;

  virtual ~ReactionOperator() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::ReactionOperator
   * \return true as object is of type ast::ReactionOperator
   */
  bool is_reaction_operator() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  ReactionOperator *clone() const override {
    return new ReactionOperator(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::REACTION_OPERATOR
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::REACTION_OPERATOR;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "ReactionOperator"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "ReactionOperator";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<ReactionOperator>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const ReactionOperator>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref ReactionOperator.value
   */
  ReactionOp get_value() const noexcept { return value; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref ReactionOperator.value
   */
  void set_value(ReactionOp value);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

  /**
   * \brief Return enum value in string form
   *
   * Enum variables (e.g. ast::BinaryOp, ast::UnitStateType) have
   * string representation when they are converted from AST back to
   * NMODL. This method is used to return corresponding string representation.
   */
  std::string eval() const { return ReactionOpNames[value]; }

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_REACTION_OPERATOR_HPP
#ifndef NMODL_AST_PAREN_EXPRESSION_HPP
#define NMODL_AST_PAREN_EXPRESSION_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class ParenExpression : public Expression {
private:
  /// TODO
  std::shared_ptr<Expression> expression;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit ParenExpression(Expression *expression);
  explicit ParenExpression(const std::shared_ptr<Expression> &expression);
  ParenExpression(const ParenExpression &obj);

  virtual ~ParenExpression() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::ParenExpression
   * \return true as object is of type ast::ParenExpression
   */
  bool is_paren_expression() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  ParenExpression *clone() const override { return new ParenExpression(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::PAREN_EXPRESSION
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::PAREN_EXPRESSION;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "ParenExpression"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "ParenExpression";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<ParenExpression>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const ParenExpression>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref ParenExpression.expression
   */
  const std::shared_ptr<Expression> &get_expression() const noexcept {
    return expression;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref ParenExpression.expression (rvalue
   * reference)
   */
  void set_expression(std::shared_ptr<Expression> &&expression);

  /**
   * \brief Setter for member variable \ref ParenExpression.expression
   */
  void set_expression(const std::shared_ptr<Expression> &expression);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_PAREN_EXPRESSION_HPP
#ifndef NMODL_AST_BINARY_EXPRESSION_HPP
#define NMODL_AST_BINARY_EXPRESSION_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents binary expression in the NMODL
 *
 * Any binary expression in the mod file is represented by this node type.
 * For example, in below example, there are three binary expressions :
 *
 * \code{.mod}
 *     BREAKPOINT {
 *         SOLVE states METHOD cnexp
 *         ina = gna*(v - ena)
 *     }
 * \endcode
 *
 * Note that the statement itself is stored in another type
 * ast::ExpressionStatement.
 *
 * \sa ast::ExpressionStatement
 *
 */
class BinaryExpression : public Expression {
private:
  /// LHS of the binary expression
  std::shared_ptr<Expression> lhs;
  /// Operator
  BinaryOperator op;
  /// RHS of the binary expression
  std::shared_ptr<Expression> rhs;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit BinaryExpression(Expression *lhs, const BinaryOperator &op,
                            Expression *rhs);
  explicit BinaryExpression(const std::shared_ptr<Expression> &lhs,
                            const BinaryOperator &op,
                            const std::shared_ptr<Expression> &rhs);
  BinaryExpression(const BinaryExpression &obj);

  virtual ~BinaryExpression() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::BinaryExpression
   * \return true as object is of type ast::BinaryExpression
   */
  bool is_binary_expression() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  BinaryExpression *clone() const override {
    return new BinaryExpression(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::BINARY_EXPRESSION
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::BINARY_EXPRESSION;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "BinaryExpression"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "BinaryExpression";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<BinaryExpression>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const BinaryExpression>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref BinaryExpression.lhs
   */
  const std::shared_ptr<Expression> &get_lhs() const noexcept { return lhs; }

  /**
   * \brief Getter for member variable \ref BinaryExpression.op
   */
  const BinaryOperator &get_op() const noexcept { return op; }

  /**
   * \brief Getter for member variable \ref BinaryExpression.rhs
   */
  const std::shared_ptr<Expression> &get_rhs() const noexcept { return rhs; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref BinaryExpression.lhs (rvalue
   * reference)
   */
  void set_lhs(std::shared_ptr<Expression> &&lhs);

  /**
   * \brief Setter for member variable \ref BinaryExpression.lhs
   */
  void set_lhs(const std::shared_ptr<Expression> &lhs);

  /**
   * \brief Setter for member variable \ref BinaryExpression.op (rvalue
   * reference)
   */
  void set_op(BinaryOperator &&op);

  /**
   * \brief Setter for member variable \ref BinaryExpression.op
   */
  void set_op(const BinaryOperator &op);

  /**
   * \brief Setter for member variable \ref BinaryExpression.rhs (rvalue
   * reference)
   */
  void set_rhs(std::shared_ptr<Expression> &&rhs);

  /**
   * \brief Setter for member variable \ref BinaryExpression.rhs
   */
  void set_rhs(const std::shared_ptr<Expression> &rhs);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_BINARY_EXPRESSION_HPP
#ifndef NMODL_AST_DIFF_EQ_EXPRESSION_HPP
#define NMODL_AST_DIFF_EQ_EXPRESSION_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents differential equation in DERIVATIVE block
 *
 *
 */
class DiffEqExpression : public Expression {
private:
  /// Differential Expression
  std::shared_ptr<BinaryExpression> expression;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit DiffEqExpression(BinaryExpression *expression);
  explicit DiffEqExpression(
      const std::shared_ptr<BinaryExpression> &expression);
  DiffEqExpression(const DiffEqExpression &obj);

  virtual ~DiffEqExpression() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::DiffEqExpression
   * \return true as object is of type ast::DiffEqExpression
   */
  bool is_diff_eq_expression() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  DiffEqExpression *clone() const override {
    return new DiffEqExpression(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::DIFF_EQ_EXPRESSION
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::DIFF_EQ_EXPRESSION;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "DiffEqExpression"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "DiffEqExpression";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<DiffEqExpression>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const DiffEqExpression>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref DiffEqExpression.expression
   */
  const std::shared_ptr<BinaryExpression> &get_expression() const noexcept {
    return expression;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref DiffEqExpression.expression (rvalue
   * reference)
   */
  void set_expression(std::shared_ptr<BinaryExpression> &&expression);

  /**
   * \brief Setter for member variable \ref DiffEqExpression.expression
   */
  void set_expression(const std::shared_ptr<BinaryExpression> &expression);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_DIFF_EQ_EXPRESSION_HPP
#ifndef NMODL_AST_UNARY_EXPRESSION_HPP
#define NMODL_AST_UNARY_EXPRESSION_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class UnaryExpression : public Expression {
private:
  /// TODO
  UnaryOperator op;
  /// TODO
  std::shared_ptr<Expression> expression;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit UnaryExpression(const UnaryOperator &op, Expression *expression);
  explicit UnaryExpression(const UnaryOperator &op,
                           const std::shared_ptr<Expression> &expression);
  UnaryExpression(const UnaryExpression &obj);

  virtual ~UnaryExpression() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::UnaryExpression
   * \return true as object is of type ast::UnaryExpression
   */
  bool is_unary_expression() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  UnaryExpression *clone() const override { return new UnaryExpression(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::UNARY_EXPRESSION
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::UNARY_EXPRESSION;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "UnaryExpression"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "UnaryExpression";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<UnaryExpression>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const UnaryExpression>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref UnaryExpression.op
   */
  const UnaryOperator &get_op() const noexcept { return op; }

  /**
   * \brief Getter for member variable \ref UnaryExpression.expression
   */
  const std::shared_ptr<Expression> &get_expression() const noexcept {
    return expression;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref UnaryExpression.op (rvalue
   * reference)
   */
  void set_op(UnaryOperator &&op);

  /**
   * \brief Setter for member variable \ref UnaryExpression.op
   */
  void set_op(const UnaryOperator &op);

  /**
   * \brief Setter for member variable \ref UnaryExpression.expression (rvalue
   * reference)
   */
  void set_expression(std::shared_ptr<Expression> &&expression);

  /**
   * \brief Setter for member variable \ref UnaryExpression.expression
   */
  void set_expression(const std::shared_ptr<Expression> &expression);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_UNARY_EXPRESSION_HPP
#ifndef NMODL_AST_NON_LIN_EQUATION_HPP
#define NMODL_AST_NON_LIN_EQUATION_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class NonLinEquation : public Expression {
private:
  /// TODO
  std::shared_ptr<Expression> lhs;
  /// TODO
  std::shared_ptr<Expression> rhs;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit NonLinEquation(Expression *lhs, Expression *rhs);
  explicit NonLinEquation(const std::shared_ptr<Expression> &lhs,
                          const std::shared_ptr<Expression> &rhs);
  NonLinEquation(const NonLinEquation &obj);

  virtual ~NonLinEquation() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::NonLinEquation
   * \return true as object is of type ast::NonLinEquation
   */
  bool is_non_lin_equation() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  NonLinEquation *clone() const override { return new NonLinEquation(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::NON_LIN_EQUATION
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::NON_LIN_EQUATION;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "NonLinEquation"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "NonLinEquation";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "~ "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "~ "; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<NonLinEquation>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const NonLinEquation>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref NonLinEquation.lhs
   */
  const std::shared_ptr<Expression> &get_lhs() const noexcept { return lhs; }

  /**
   * \brief Getter for member variable \ref NonLinEquation.rhs
   */
  const std::shared_ptr<Expression> &get_rhs() const noexcept { return rhs; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref NonLinEquation.lhs (rvalue
   * reference)
   */
  void set_lhs(std::shared_ptr<Expression> &&lhs);

  /**
   * \brief Setter for member variable \ref NonLinEquation.lhs
   */
  void set_lhs(const std::shared_ptr<Expression> &lhs);

  /**
   * \brief Setter for member variable \ref NonLinEquation.rhs (rvalue
   * reference)
   */
  void set_rhs(std::shared_ptr<Expression> &&rhs);

  /**
   * \brief Setter for member variable \ref NonLinEquation.rhs
   */
  void set_rhs(const std::shared_ptr<Expression> &rhs);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_NON_LIN_EQUATION_HPP
#ifndef NMODL_AST_LIN_EQUATION_HPP
#define NMODL_AST_LIN_EQUATION_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class LinEquation : public Expression {
private:
  /// TODO
  std::shared_ptr<Expression> left_linxpression;
  /// TODO
  std::shared_ptr<Expression> linxpression;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit LinEquation(Expression *left_linxpression, Expression *linxpression);
  explicit LinEquation(const std::shared_ptr<Expression> &left_linxpression,
                       const std::shared_ptr<Expression> &linxpression);
  LinEquation(const LinEquation &obj);

  virtual ~LinEquation() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::LinEquation
   * \return true as object is of type ast::LinEquation
   */
  bool is_lin_equation() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  LinEquation *clone() const override { return new LinEquation(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::LIN_EQUATION
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::LIN_EQUATION;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "LinEquation"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "LinEquation";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "~ "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "~ "; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<LinEquation>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const LinEquation>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref LinEquation.left_linxpression
   */
  const std::shared_ptr<Expression> &get_left_linxpression() const noexcept {
    return left_linxpression;
  }

  /**
   * \brief Getter for member variable \ref LinEquation.linxpression
   */
  const std::shared_ptr<Expression> &get_linxpression() const noexcept {
    return linxpression;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref LinEquation.left_linxpression
   * (rvalue reference)
   */
  void set_left_linxpression(std::shared_ptr<Expression> &&left_linxpression);

  /**
   * \brief Setter for member variable \ref LinEquation.left_linxpression
   */
  void
  set_left_linxpression(const std::shared_ptr<Expression> &left_linxpression);

  /**
   * \brief Setter for member variable \ref LinEquation.linxpression (rvalue
   * reference)
   */
  void set_linxpression(std::shared_ptr<Expression> &&linxpression);

  /**
   * \brief Setter for member variable \ref LinEquation.linxpression
   */
  void set_linxpression(const std::shared_ptr<Expression> &linxpression);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_LIN_EQUATION_HPP
#ifndef NMODL_AST_FUNCTION_CALL_HPP
#define NMODL_AST_FUNCTION_CALL_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class FunctionCall : public Expression {
private:
  /// TODO
  std::shared_ptr<Name> name;
  /// TODO
  ExpressionVector arguments;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit FunctionCall(Name *name, ExpressionVector arguments);
  explicit FunctionCall(const std::shared_ptr<Name> &name,
                        const ExpressionVector &arguments);
  FunctionCall(const FunctionCall &obj);

  virtual ~FunctionCall() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::FunctionCall
   * \return true as object is of type ast::FunctionCall
   */
  bool is_function_call() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  FunctionCall *clone() const override { return new FunctionCall(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::FUNCTION_CALL
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::FUNCTION_CALL;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "FunctionCall"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "FunctionCall";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<FunctionCall>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const FunctionCall>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return name of the node
   *
   * Some ast nodes have a member marked designated as node name. For example,
   * in case of this ast::Name has name designated as a
   * node name.
   *
   * @return name of the node as std::string
   *
   * \sa Ast::get_node_type_name
   */
  std::string get_node_name() const override;

  /**
   * \brief Getter for member variable \ref FunctionCall.name
   */
  const std::shared_ptr<Name> &get_name() const noexcept { return name; }

  /**
   * \brief Getter for member variable \ref FunctionCall.arguments
   */
  const ExpressionVector &get_arguments() const noexcept { return arguments; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref FunctionCall.name (rvalue reference)
   */
  void set_name(std::shared_ptr<Name> &&name);

  /**
   * \brief Setter for member variable \ref FunctionCall.name
   */
  void set_name(const std::shared_ptr<Name> &name);

  /**
   * \brief Setter for member variable \ref FunctionCall.arguments (rvalue
   * reference)
   */
  void set_arguments(ExpressionVector &&arguments);

  /**
   * \brief Setter for member variable \ref FunctionCall.arguments
   */
  void set_arguments(const ExpressionVector &arguments);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_FUNCTION_CALL_HPP
#ifndef NMODL_AST_FIRST_LAST_TYPE_INDEX_HPP
#define NMODL_AST_FIRST_LAST_TYPE_INDEX_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class FirstLastTypeIndex : public Expression {
private:
  /// TODO
  FirstLastType value;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit FirstLastTypeIndex(FirstLastType value);
  FirstLastTypeIndex(const FirstLastTypeIndex &obj);

  virtual ~FirstLastTypeIndex() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::FirstLastTypeIndex
   * \return true as object is of type ast::FirstLastTypeIndex
   */
  bool is_first_last_type_index() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  FirstLastTypeIndex *clone() const override {
    return new FirstLastTypeIndex(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::FIRST_LAST_TYPE_INDEX
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::FIRST_LAST_TYPE_INDEX;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "FirstLastTypeIndex"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "FirstLastTypeIndex";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<FirstLastTypeIndex>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const FirstLastTypeIndex>(
        shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref FirstLastTypeIndex.value
   */
  FirstLastType get_value() const noexcept { return value; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref FirstLastTypeIndex.value
   */
  void set_value(FirstLastType value);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

  /**
   * \brief Return enum value in string form
   *
   * Enum variables (e.g. ast::BinaryOp, ast::UnitStateType) have
   * string representation when they are converted from AST back to
   * NMODL. This method is used to return corresponding string representation.
   */
  std::string eval() const { return FirstLastTypeNames[value]; }

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_FIRST_LAST_TYPE_INDEX_HPP
#ifndef NMODL_AST_WATCH_HPP
#define NMODL_AST_WATCH_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class Watch : public Expression {
private:
  /// TODO
  std::shared_ptr<Expression> expression;
  /// TODO
  std::shared_ptr<Expression> value;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit Watch(Expression *expression, Expression *value);
  explicit Watch(const std::shared_ptr<Expression> &expression,
                 const std::shared_ptr<Expression> &value);
  Watch(const Watch &obj);

  virtual ~Watch() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::Watch
   * \return true as object is of type ast::Watch
   */
  bool is_watch() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  Watch *clone() const override { return new Watch(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::WATCH
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::WATCH;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Watch"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override { return "Watch"; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Watch>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Watch>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref Watch.expression
   */
  const std::shared_ptr<Expression> &get_expression() const noexcept {
    return expression;
  }

  /**
   * \brief Getter for member variable \ref Watch.value
   */
  const std::shared_ptr<Expression> &get_value() const noexcept {
    return value;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref Watch.expression (rvalue reference)
   */
  void set_expression(std::shared_ptr<Expression> &&expression);

  /**
   * \brief Setter for member variable \ref Watch.expression
   */
  void set_expression(const std::shared_ptr<Expression> &expression);

  /**
   * \brief Setter for member variable \ref Watch.value (rvalue reference)
   */
  void set_value(std::shared_ptr<Expression> &&value);

  /**
   * \brief Setter for member variable \ref Watch.value
   */
  void set_value(const std::shared_ptr<Expression> &value);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_WATCH_HPP
#ifndef NMODL_AST_QUEUE_EXPRESSION_TYPE_HPP
#define NMODL_AST_QUEUE_EXPRESSION_TYPE_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class QueueExpressionType : public Expression {
private:
  /// TODO
  QueueType value;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit QueueExpressionType(QueueType value);
  QueueExpressionType(const QueueExpressionType &obj);

  virtual ~QueueExpressionType() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::QueueExpressionType
   * \return true as object is of type ast::QueueExpressionType
   */
  bool is_queue_expression_type() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  QueueExpressionType *clone() const override {
    return new QueueExpressionType(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::QUEUE_EXPRESSION_TYPE
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::QUEUE_EXPRESSION_TYPE;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "QueueExpressionType"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "QueueExpressionType";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<QueueExpressionType>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const QueueExpressionType>(
        shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref QueueExpressionType.value
   */
  QueueType get_value() const noexcept { return value; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref QueueExpressionType.value
   */
  void set_value(QueueType value);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

  /**
   * \brief Return enum value in string form
   *
   * Enum variables (e.g. ast::BinaryOp, ast::UnitStateType) have
   * string representation when they are converted from AST back to
   * NMODL. This method is used to return corresponding string representation.
   */
  std::string eval() const { return QueueTypeNames[value]; }

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_QUEUE_EXPRESSION_TYPE_HPP
#ifndef NMODL_AST_MATCH_HPP
#define NMODL_AST_MATCH_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class Match : public Expression {
private:
  /// TODO
  std::shared_ptr<Identifier> name;
  /// TODO
  std::shared_ptr<Expression> expression;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit Match(Identifier *name, Expression *expression);
  explicit Match(const std::shared_ptr<Identifier> &name,
                 const std::shared_ptr<Expression> &expression);
  Match(const Match &obj);

  virtual ~Match() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::Match
   * \return true as object is of type ast::Match
   */
  bool is_match() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  Match *clone() const override { return new Match(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::MATCH
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::MATCH;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Match"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override { return "Match"; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Match>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Match>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref Match.name
   */
  const std::shared_ptr<Identifier> &get_name() const noexcept { return name; }

  /**
   * \brief Getter for member variable \ref Match.expression
   */
  const std::shared_ptr<Expression> &get_expression() const noexcept {
    return expression;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref Match.name (rvalue reference)
   */
  void set_name(std::shared_ptr<Identifier> &&name);

  /**
   * \brief Setter for member variable \ref Match.name
   */
  void set_name(const std::shared_ptr<Identifier> &name);

  /**
   * \brief Setter for member variable \ref Match.expression (rvalue reference)
   */
  void set_expression(std::shared_ptr<Expression> &&expression);

  /**
   * \brief Setter for member variable \ref Match.expression
   */
  void set_expression(const std::shared_ptr<Expression> &expression);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_MATCH_HPP
#ifndef NMODL_AST_BA_BLOCK_TYPE_HPP
#define NMODL_AST_BA_BLOCK_TYPE_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Type to represent different block types for before/after block
 *
 * Different NMODL blocks can be used with ast::BeforeBlock and ast::AfterBlock.
 * This type is used to represent such block types.
 *
 * \sa ast::BeforeBlock as::AfterBlock
 *
 */
class BABlockType : public Expression {
private:
  /// block type
  BAType value;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit BABlockType(BAType value);
  BABlockType(const BABlockType &obj);

  virtual ~BABlockType() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::BABlockType
   * \return true as object is of type ast::BABlockType
   */
  bool is_ba_block_type() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  BABlockType *clone() const override { return new BABlockType(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::BA_BLOCK_TYPE
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::BA_BLOCK_TYPE;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "BABlockType"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "BABlockType";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<BABlockType>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const BABlockType>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref BABlockType.value
   */
  BAType get_value() const noexcept { return value; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref BABlockType.value
   */
  void set_value(BAType value);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

  /**
   * \brief Return enum value in string form
   *
   * Enum variables (e.g. ast::BinaryOp, ast::UnitStateType) have
   * string representation when they are converted from AST back to
   * NMODL. This method is used to return corresponding string representation.
   */
  std::string eval() const { return BATypeNames[value]; }

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_BA_BLOCK_TYPE_HPP
#ifndef NMODL_AST_UNIT_DEF_HPP
#define NMODL_AST_UNIT_DEF_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class UnitDef : public Expression {
private:
  /// TODO
  std::shared_ptr<Unit> unit1;
  /// TODO
  std::shared_ptr<Unit> unit2;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit UnitDef(Unit *unit1, Unit *unit2);
  explicit UnitDef(const std::shared_ptr<Unit> &unit1,
                   const std::shared_ptr<Unit> &unit2);
  UnitDef(const UnitDef &obj);

  virtual ~UnitDef() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::UnitDef
   * \return true as object is of type ast::UnitDef
   */
  bool is_unit_def() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  UnitDef *clone() const override { return new UnitDef(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::UNIT_DEF
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::UNIT_DEF;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "UnitDef"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override { return "UnitDef"; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<UnitDef>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const UnitDef>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return name of the node
   *
   * Some ast nodes have a member marked designated as node name. For example,
   * in case of this ast::Unit has unit1 designated as a
   * node name.
   *
   * @return name of the node as std::string
   *
   * \sa Ast::get_node_type_name
   */
  std::string get_node_name() const override;

  /**
   * \brief Getter for member variable \ref UnitDef.unit1
   */
  const std::shared_ptr<Unit> &get_unit1() const noexcept { return unit1; }

  /**
   * \brief Getter for member variable \ref UnitDef.unit2
   */
  const std::shared_ptr<Unit> &get_unit2() const noexcept { return unit2; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref UnitDef.unit1 (rvalue reference)
   */
  void set_unit1(std::shared_ptr<Unit> &&unit1);

  /**
   * \brief Setter for member variable \ref UnitDef.unit1
   */
  void set_unit1(const std::shared_ptr<Unit> &unit1);

  /**
   * \brief Setter for member variable \ref UnitDef.unit2 (rvalue reference)
   */
  void set_unit2(std::shared_ptr<Unit> &&unit2);

  /**
   * \brief Setter for member variable \ref UnitDef.unit2
   */
  void set_unit2(const std::shared_ptr<Unit> &unit2);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_UNIT_DEF_HPP
#ifndef NMODL_AST_FACTOR_DEF_HPP
#define NMODL_AST_FACTOR_DEF_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class FactorDef : public Expression {
private:
  /// TODO
  std::shared_ptr<Name> name;
  /// TODO
  std::shared_ptr<Double> value;
  /// TODO
  std::shared_ptr<Unit> unit1;
  /// Todo: Michael : rename variable gt as well
  std::shared_ptr<Boolean> gt;
  /// TODO
  std::shared_ptr<Unit> unit2;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit FactorDef(Name *name, Double *value, Unit *unit1, Boolean *gt,
                     Unit *unit2);
  explicit FactorDef(const std::shared_ptr<Name> &name,
                     const std::shared_ptr<Double> &value,
                     const std::shared_ptr<Unit> &unit1,
                     const std::shared_ptr<Boolean> &gt,
                     const std::shared_ptr<Unit> &unit2);
  FactorDef(const FactorDef &obj);

  FactorDef() = default;

  virtual ~FactorDef() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::FactorDef
   * \return true as object is of type ast::FactorDef
   */
  bool is_factor_def() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  FactorDef *clone() const override { return new FactorDef(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::FACTOR_DEF
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::FACTOR_DEF;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "FactorDef"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "FactorDef";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<FactorDef>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const FactorDef>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return name of the node
   *
   * Some ast nodes have a member marked designated as node name. For example,
   * in case of this ast::Name has name designated as a
   * node name.
   *
   * @return name of the node as std::string
   *
   * \sa Ast::get_node_type_name
   */
  std::string get_node_name() const override;

  /**
   * \brief Getter for member variable \ref FactorDef.name
   */
  const std::shared_ptr<Name> &get_name() const noexcept { return name; }

  /**
   * \brief Getter for member variable \ref FactorDef.value
   */
  const std::shared_ptr<Double> &get_value() const noexcept { return value; }

  /**
   * \brief Getter for member variable \ref FactorDef.unit1
   */
  const std::shared_ptr<Unit> &get_unit1() const noexcept { return unit1; }

  /**
   * \brief Getter for member variable \ref FactorDef.gt
   */
  const std::shared_ptr<Boolean> &get_gt() const noexcept { return gt; }

  /**
   * \brief Getter for member variable \ref FactorDef.unit2
   */
  const std::shared_ptr<Unit> &get_unit2() const noexcept { return unit2; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref FactorDef.name (rvalue reference)
   */
  void set_name(std::shared_ptr<Name> &&name);

  /**
   * \brief Setter for member variable \ref FactorDef.name
   */
  void set_name(const std::shared_ptr<Name> &name);

  /**
   * \brief Setter for member variable \ref FactorDef.value (rvalue reference)
   */
  void set_value(std::shared_ptr<Double> &&value);

  /**
   * \brief Setter for member variable \ref FactorDef.value
   */
  void set_value(const std::shared_ptr<Double> &value);

  /**
   * \brief Setter for member variable \ref FactorDef.unit1 (rvalue reference)
   */
  void set_unit1(std::shared_ptr<Unit> &&unit1);

  /**
   * \brief Setter for member variable \ref FactorDef.unit1
   */
  void set_unit1(const std::shared_ptr<Unit> &unit1);

  /**
   * \brief Setter for member variable \ref FactorDef.gt (rvalue reference)
   */
  void set_gt(std::shared_ptr<Boolean> &&gt);

  /**
   * \brief Setter for member variable \ref FactorDef.gt
   */
  void set_gt(const std::shared_ptr<Boolean> &gt);

  /**
   * \brief Setter for member variable \ref FactorDef.unit2 (rvalue reference)
   */
  void set_unit2(std::shared_ptr<Unit> &&unit2);

  /**
   * \brief Setter for member variable \ref FactorDef.unit2
   */
  void set_unit2(const std::shared_ptr<Unit> &unit2);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_FACTOR_DEF_HPP
#ifndef NMODL_AST_VALENCE_HPP
#define NMODL_AST_VALENCE_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class Valence : public Expression {
private:
  /// TODO
  std::shared_ptr<Name> type;
  /// TODO
  std::shared_ptr<Double> value;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit Valence(Name *type, Double *value);
  explicit Valence(const std::shared_ptr<Name> &type,
                   const std::shared_ptr<Double> &value);
  Valence(const Valence &obj);

  virtual ~Valence() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::Valence
   * \return true as object is of type ast::Valence
   */
  bool is_valence() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  Valence *clone() const override { return new Valence(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::VALENCE
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::VALENCE;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Valence"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override { return "Valence"; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Valence>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Valence>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref Valence.type
   */
  const std::shared_ptr<Name> &get_type() const noexcept { return type; }

  /**
   * \brief Getter for member variable \ref Valence.value
   */
  const std::shared_ptr<Double> &get_value() const noexcept { return value; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref Valence.type (rvalue reference)
   */
  void set_type(std::shared_ptr<Name> &&type);

  /**
   * \brief Setter for member variable \ref Valence.type
   */
  void set_type(const std::shared_ptr<Name> &type);

  /**
   * \brief Setter for member variable \ref Valence.value (rvalue reference)
   */
  void set_value(std::shared_ptr<Double> &&value);

  /**
   * \brief Setter for member variable \ref Valence.value
   */
  void set_value(const std::shared_ptr<Double> &value);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_VALENCE_HPP
#ifndef NMODL_AST_UNIT_STATE_HPP
#define NMODL_AST_UNIT_STATE_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class UnitState : public Statement {
private:
  /// TODO
  UnitStateType value;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit UnitState(UnitStateType value);
  UnitState(const UnitState &obj);

  virtual ~UnitState() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::UnitState
   * \return true as object is of type ast::UnitState
   */
  bool is_unit_state() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  UnitState *clone() const override { return new UnitState(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::UNIT_STATE
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::UNIT_STATE;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "UnitState"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "UnitState";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<UnitState>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const UnitState>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref UnitState.value
   */
  UnitStateType get_value() const noexcept { return value; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref UnitState.value
   */
  void set_value(UnitStateType value);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

  /**
   * \brief Return enum value in string form
   *
   * Enum variables (e.g. ast::BinaryOp, ast::UnitStateType) have
   * string representation when they are converted from AST back to
   * NMODL. This method is used to return corresponding string representation.
   */
  std::string eval() const { return UnitStateTypeNames[value]; }

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_UNIT_STATE_HPP
#ifndef NMODL_AST_LOCAL_LIST_STATEMENT_HPP
#define NMODL_AST_LOCAL_LIST_STATEMENT_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class LocalListStatement : public Statement {
private:
  /// TODO
  LocalVarVector variables;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit LocalListStatement(LocalVarVector variables);
  LocalListStatement(const LocalListStatement &obj);

  virtual ~LocalListStatement() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::LocalListStatement
   * \return true as object is of type ast::LocalListStatement
   */
  bool is_local_list_statement() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  LocalListStatement *clone() const override {
    return new LocalListStatement(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::LOCAL_LIST_STATEMENT
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::LOCAL_LIST_STATEMENT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "LocalListStatement"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "LocalListStatement";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "LOCAL "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "LOCAL "; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<LocalListStatement>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const LocalListStatement>(
        shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Add member to variables by raw pointer
   */
  void emplace_back_local_var(LocalVar *n) {
    variables.emplace_back(n);

    // set parents
    n->set_parent(this);
  }

  /**
   * \brief Add member to variables by shared_ptr
   */
  void emplace_back_local_var(std::shared_ptr<LocalVar> n) {
    variables.emplace_back(n);
    // set parents
    n->set_parent(this);
  }

  /**
   * \brief Erase member to variables
   */
  LocalVarVector::const_iterator
  erase_local_var(LocalVarVector::const_iterator first) {
    auto first_it = const_iter_cast(variables, first);
    return variables.erase(first_it);
  }
  /**
   * \brief Erase members to variables
   */
  LocalVarVector::const_iterator
  erase_local_var(LocalVarVector::const_iterator first,
                  LocalVarVector::const_iterator last) {
    auto first_it = const_iter_cast(variables, first);
    auto last_it = const_iter_cast(variables, last);
    return variables.erase(first_it, last_it);
  }
  /**
   * \brief Erase non-consecutive members to variables
   *
   * loosely following the cpp reference of remove_if
   */
  size_t erase_local_var(std::unordered_set<LocalVar *> &to_be_erased) {
    auto first = variables.begin();
    auto last = variables.end();
    auto result = first;

    while (first != last) {
      // automatically erase dangling pointers from the uset while
      // looking for them to erase them in the vector
      if (to_be_erased.erase(first->get()) == 0) {
        reset_local_var(result, *first);
        ++result;
      }
      ++first;
    }

    size_t out = last - result;
    erase_local_var(result, last);

    return out;
  }

  /**
   * \brief Insert member to variables
   */
  LocalVarVector::const_iterator
  insert_local_var(LocalVarVector::const_iterator position,
                   const std::shared_ptr<LocalVar> &n) {
    n->set_parent(this);
    auto pos_it = const_iter_cast(variables, position);
    return variables.insert(pos_it, n);
  }
  /**
   * \brief Insert members to variables
   */
  template <class NodeType, class InputIterator>
  void insert_local_var(LocalVarVector::const_iterator position, NodeType &to,
                        InputIterator first, InputIterator last) {

    for (auto it = first; it != last; ++it) {
      auto &n = *it;
      // set parents
      n->set_parent(this);
    }
    auto pos_it = const_iter_cast(variables, position);
    auto first_it = const_iter_cast(to, first);
    auto last_it = const_iter_cast(to, last);
    variables.insert(pos_it, first_it, last_it);
  }

  /**
   * \brief Reset member to variables
   */
  void reset_local_var(LocalVarVector::const_iterator position, LocalVar *n) {
    // set parents
    n->set_parent(this);

    variables[position - variables.begin()].reset(n);
  }

  /**
   * \brief Reset member to variables
   */
  void reset_local_var(LocalVarVector::const_iterator position,
                       std::shared_ptr<LocalVar> n) {
    // set parents
    n->set_parent(this);

    variables[position - variables.begin()] = n;
  }

  /**
   * \brief Getter for member variable \ref LocalListStatement.variables
   */
  const LocalVarVector &get_variables() const noexcept { return variables; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref LocalListStatement.variables (rvalue
   * reference)
   */
  void set_variables(LocalVarVector &&variables);

  /**
   * \brief Setter for member variable \ref LocalListStatement.variables
   */
  void set_variables(const LocalVarVector &variables);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_LOCAL_LIST_STATEMENT_HPP
#ifndef NMODL_AST_MODEL_HPP
#define NMODL_AST_MODEL_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class Model : public Statement {
private:
  /// TODO
  std::shared_ptr<String> title;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit Model(String *title);
  explicit Model(const std::shared_ptr<String> &title);
  Model(const Model &obj);

  virtual ~Model() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::Model
   * \return true as object is of type ast::Model
   */
  bool is_model() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  Model *clone() const override { return new Model(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::MODEL
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::MODEL;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Model"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override { return "Model"; }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "TITLE"
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "TITLE"; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Model>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Model>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref Model.title
   */
  const std::shared_ptr<String> &get_title() const noexcept { return title; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref Model.title (rvalue reference)
   */
  void set_title(std::shared_ptr<String> &&title);

  /**
   * \brief Setter for member variable \ref Model.title
   */
  void set_title(const std::shared_ptr<String> &title);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_MODEL_HPP
#ifndef NMODL_AST_DEFINE_HPP
#define NMODL_AST_DEFINE_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a `DEFINE` statement in NMODL
 *
 *
 */
class Define : public Statement {
private:
  /// Name of the macro
  std::shared_ptr<Name> name;
  /// Value of the macro
  std::shared_ptr<Integer> value;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit Define(Name *name, Integer *value);
  explicit Define(const std::shared_ptr<Name> &name,
                  const std::shared_ptr<Integer> &value);
  Define(const Define &obj);

  virtual ~Define() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::Define
   * \return true as object is of type ast::Define
   */
  bool is_define() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  Define *clone() const override { return new Define(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::DEFINE
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::DEFINE;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Define"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override { return "Define"; }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "DEFINE "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "DEFINE "; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Define>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Define>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return name of the node
   *
   * Some ast nodes have a member marked designated as node name. For example,
   * in case of this ast::Name has name designated as a
   * node name.
   *
   * @return name of the node as std::string
   *
   * \sa Ast::get_node_type_name
   */
  std::string get_node_name() const override;

  /**
   * \brief Getter for member variable \ref Define.name
   */
  const std::shared_ptr<Name> &get_name() const noexcept { return name; }

  /**
   * \brief Getter for member variable \ref Define.value
   */
  const std::shared_ptr<Integer> &get_value() const noexcept { return value; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref Define.name (rvalue reference)
   */
  void set_name(std::shared_ptr<Name> &&name);

  /**
   * \brief Setter for member variable \ref Define.name
   */
  void set_name(const std::shared_ptr<Name> &name);

  /**
   * \brief Setter for member variable \ref Define.value (rvalue reference)
   */
  void set_value(std::shared_ptr<Integer> &&value);

  /**
   * \brief Setter for member variable \ref Define.value
   */
  void set_value(const std::shared_ptr<Integer> &value);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_DEFINE_HPP
#ifndef NMODL_AST_INCLUDE_HPP
#define NMODL_AST_INCLUDE_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class Include : public Statement {
private:
  /// TODO
  std::shared_ptr<String> filename;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit Include(String *filename);
  explicit Include(const std::shared_ptr<String> &filename);
  Include(const Include &obj);

  virtual ~Include() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::Include
   * \return true as object is of type ast::Include
   */
  bool is_include() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  Include *clone() const override { return new Include(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::INCLUDE
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::INCLUDE;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Include"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override { return "Include"; }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "INCLUDE "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "INCLUDE "; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Include>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Include>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref Include.filename
   */
  const std::shared_ptr<String> &get_filename() const noexcept {
    return filename;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref Include.filename (rvalue reference)
   */
  void set_filename(std::shared_ptr<String> &&filename);

  /**
   * \brief Setter for member variable \ref Include.filename
   */
  void set_filename(const std::shared_ptr<String> &filename);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_INCLUDE_HPP
#ifndef NMODL_AST_PARAM_ASSIGN_HPP
#define NMODL_AST_PARAM_ASSIGN_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class ParamAssign : public Statement {
private:
  /// TODO
  std::shared_ptr<Identifier> name;
  /// TODO
  std::shared_ptr<Number> value;
  /// TODO
  std::shared_ptr<Unit> unit;
  /// TODO
  std::shared_ptr<Limits> limit;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit ParamAssign(Identifier *name, Number *value, Unit *unit,
                       Limits *limit);
  explicit ParamAssign(const std::shared_ptr<Identifier> &name,
                       const std::shared_ptr<Number> &value,
                       const std::shared_ptr<Unit> &unit,
                       const std::shared_ptr<Limits> &limit);
  ParamAssign(const ParamAssign &obj);

  virtual ~ParamAssign() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::ParamAssign
   * \return true as object is of type ast::ParamAssign
   */
  bool is_param_assign() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  ParamAssign *clone() const override { return new ParamAssign(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::PARAM_ASSIGN
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::PARAM_ASSIGN;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "ParamAssign"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "ParamAssign";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<ParamAssign>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const ParamAssign>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return name of the node
   *
   * Some ast nodes have a member marked designated as node name. For example,
   * in case of this ast::Identifier has name designated as a
   * node name.
   *
   * @return name of the node as std::string
   *
   * \sa Ast::get_node_type_name
   */
  std::string get_node_name() const override;

  /**
   * \brief Getter for member variable \ref ParamAssign.name
   */
  const std::shared_ptr<Identifier> &get_name() const noexcept { return name; }

  /**
   * \brief Getter for member variable \ref ParamAssign.value
   */
  const std::shared_ptr<Number> &get_value() const noexcept { return value; }

  /**
   * \brief Getter for member variable \ref ParamAssign.unit
   */
  const std::shared_ptr<Unit> &get_unit() const noexcept { return unit; }

  /**
   * \brief Getter for member variable \ref ParamAssign.limit
   */
  const std::shared_ptr<Limits> &get_limit() const noexcept { return limit; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref ParamAssign.name (rvalue reference)
   */
  void set_name(std::shared_ptr<Identifier> &&name);

  /**
   * \brief Setter for member variable \ref ParamAssign.name
   */
  void set_name(const std::shared_ptr<Identifier> &name);

  /**
   * \brief Setter for member variable \ref ParamAssign.value (rvalue reference)
   */
  void set_value(std::shared_ptr<Number> &&value);

  /**
   * \brief Setter for member variable \ref ParamAssign.value
   */
  void set_value(const std::shared_ptr<Number> &value);

  /**
   * \brief Setter for member variable \ref ParamAssign.unit (rvalue reference)
   */
  void set_unit(std::shared_ptr<Unit> &&unit);

  /**
   * \brief Setter for member variable \ref ParamAssign.unit
   */
  void set_unit(const std::shared_ptr<Unit> &unit);

  /**
   * \brief Setter for member variable \ref ParamAssign.limit (rvalue reference)
   */
  void set_limit(std::shared_ptr<Limits> &&limit);

  /**
   * \brief Setter for member variable \ref ParamAssign.limit
   */
  void set_limit(const std::shared_ptr<Limits> &limit);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_PARAM_ASSIGN_HPP
#ifndef NMODL_AST_STEPPED_HPP
#define NMODL_AST_STEPPED_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class Stepped : public Statement {
private:
  /// TODO
  std::shared_ptr<Name> name;
  /// TODO
  NumberVector values;
  /// TODO
  std::shared_ptr<Unit> unit;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit Stepped(Name *name, NumberVector values, Unit *unit);
  explicit Stepped(const std::shared_ptr<Name> &name,
                   const NumberVector &values,
                   const std::shared_ptr<Unit> &unit);
  Stepped(const Stepped &obj);

  virtual ~Stepped() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::Stepped
   * \return true as object is of type ast::Stepped
   */
  bool is_stepped() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  Stepped *clone() const override { return new Stepped(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::STEPPED
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::STEPPED;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Stepped"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override { return "Stepped"; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Stepped>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Stepped>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref Stepped.name
   */
  const std::shared_ptr<Name> &get_name() const noexcept { return name; }

  /**
   * \brief Getter for member variable \ref Stepped.values
   */
  const NumberVector &get_values() const noexcept { return values; }

  /**
   * \brief Getter for member variable \ref Stepped.unit
   */
  const std::shared_ptr<Unit> &get_unit() const noexcept { return unit; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref Stepped.name (rvalue reference)
   */
  void set_name(std::shared_ptr<Name> &&name);

  /**
   * \brief Setter for member variable \ref Stepped.name
   */
  void set_name(const std::shared_ptr<Name> &name);

  /**
   * \brief Setter for member variable \ref Stepped.values (rvalue reference)
   */
  void set_values(NumberVector &&values);

  /**
   * \brief Setter for member variable \ref Stepped.values
   */
  void set_values(const NumberVector &values);

  /**
   * \brief Setter for member variable \ref Stepped.unit (rvalue reference)
   */
  void set_unit(std::shared_ptr<Unit> &&unit);

  /**
   * \brief Setter for member variable \ref Stepped.unit
   */
  void set_unit(const std::shared_ptr<Unit> &unit);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_STEPPED_HPP
#ifndef NMODL_AST_INDEPENDENT_DEFINITION_HPP
#define NMODL_AST_INDEPENDENT_DEFINITION_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class IndependentDefinition : public Statement {
private:
  /// TODO
  std::shared_ptr<Boolean> sweep;
  /// TODO
  std::shared_ptr<Name> name;
  /// TODO
  std::shared_ptr<Number> from;
  /// TODO
  std::shared_ptr<Number> to;
  /// TODO
  std::shared_ptr<Integer> with;
  /// TODO
  std::shared_ptr<Number> start;
  /// TODO
  std::shared_ptr<Unit> unit;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit IndependentDefinition(Boolean *sweep, Name *name, Number *from,
                                 Number *to, Integer *with, Number *start,
                                 Unit *unit);
  explicit IndependentDefinition(const std::shared_ptr<Boolean> &sweep,
                                 const std::shared_ptr<Name> &name,
                                 const std::shared_ptr<Number> &from,
                                 const std::shared_ptr<Number> &to,
                                 const std::shared_ptr<Integer> &with,
                                 const std::shared_ptr<Number> &start,
                                 const std::shared_ptr<Unit> &unit);
  IndependentDefinition(const IndependentDefinition &obj);

  virtual ~IndependentDefinition() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::IndependentDefinition
   * \return true as object is of type ast::IndependentDefinition
   */
  bool is_independent_definition() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  IndependentDefinition *clone() const override {
    return new IndependentDefinition(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::INDEPENDENT_DEFINITION
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::INDEPENDENT_DEFINITION;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "IndependentDefinition"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "IndependentDefinition";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<IndependentDefinition>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const IndependentDefinition>(
        shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref IndependentDefinition.sweep
   */
  const std::shared_ptr<Boolean> &get_sweep() const noexcept { return sweep; }

  /**
   * \brief Getter for member variable \ref IndependentDefinition.name
   */
  const std::shared_ptr<Name> &get_name() const noexcept { return name; }

  /**
   * \brief Getter for member variable \ref IndependentDefinition.from
   */
  const std::shared_ptr<Number> &get_from() const noexcept { return from; }

  /**
   * \brief Getter for member variable \ref IndependentDefinition.to
   */
  const std::shared_ptr<Number> &get_to() const noexcept { return to; }

  /**
   * \brief Getter for member variable \ref IndependentDefinition.with
   */
  const std::shared_ptr<Integer> &get_with() const noexcept { return with; }

  /**
   * \brief Getter for member variable \ref IndependentDefinition.start
   */
  const std::shared_ptr<Number> &get_start() const noexcept { return start; }

  /**
   * \brief Getter for member variable \ref IndependentDefinition.unit
   */
  const std::shared_ptr<Unit> &get_unit() const noexcept { return unit; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref IndependentDefinition.sweep (rvalue
   * reference)
   */
  void set_sweep(std::shared_ptr<Boolean> &&sweep);

  /**
   * \brief Setter for member variable \ref IndependentDefinition.sweep
   */
  void set_sweep(const std::shared_ptr<Boolean> &sweep);

  /**
   * \brief Setter for member variable \ref IndependentDefinition.name (rvalue
   * reference)
   */
  void set_name(std::shared_ptr<Name> &&name);

  /**
   * \brief Setter for member variable \ref IndependentDefinition.name
   */
  void set_name(const std::shared_ptr<Name> &name);

  /**
   * \brief Setter for member variable \ref IndependentDefinition.from (rvalue
   * reference)
   */
  void set_from(std::shared_ptr<Number> &&from);

  /**
   * \brief Setter for member variable \ref IndependentDefinition.from
   */
  void set_from(const std::shared_ptr<Number> &from);

  /**
   * \brief Setter for member variable \ref IndependentDefinition.to (rvalue
   * reference)
   */
  void set_to(std::shared_ptr<Number> &&to);

  /**
   * \brief Setter for member variable \ref IndependentDefinition.to
   */
  void set_to(const std::shared_ptr<Number> &to);

  /**
   * \brief Setter for member variable \ref IndependentDefinition.with (rvalue
   * reference)
   */
  void set_with(std::shared_ptr<Integer> &&with);

  /**
   * \brief Setter for member variable \ref IndependentDefinition.with
   */
  void set_with(const std::shared_ptr<Integer> &with);

  /**
   * \brief Setter for member variable \ref IndependentDefinition.start (rvalue
   * reference)
   */
  void set_start(std::shared_ptr<Number> &&start);

  /**
   * \brief Setter for member variable \ref IndependentDefinition.start
   */
  void set_start(const std::shared_ptr<Number> &start);

  /**
   * \brief Setter for member variable \ref IndependentDefinition.unit (rvalue
   * reference)
   */
  void set_unit(std::shared_ptr<Unit> &&unit);

  /**
   * \brief Setter for member variable \ref IndependentDefinition.unit
   */
  void set_unit(const std::shared_ptr<Unit> &unit);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_INDEPENDENT_DEFINITION_HPP
#ifndef NMODL_AST_ASSIGNED_DEFINITION_HPP
#define NMODL_AST_ASSIGNED_DEFINITION_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a statement in `ASSIGNED` or `STATE` block
 *
 *
 */
class AssignedDefinition : public Statement {
private:
  /// Name of the variable
  std::shared_ptr<Identifier> name;
  /// Length in case of array
  std::shared_ptr<Integer> length;
  /// TODO
  std::shared_ptr<Number> from;
  /// TODO
  std::shared_ptr<Number> to;
  /// TODO
  std::shared_ptr<Number> start;
  /// TODO
  std::shared_ptr<Unit> unit;
  /// TODO
  std::shared_ptr<Double> abstol;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit AssignedDefinition(Identifier *name, Integer *length, Number *from,
                              Number *to, Number *start, Unit *unit,
                              Double *abstol);
  explicit AssignedDefinition(const std::shared_ptr<Identifier> &name,
                              const std::shared_ptr<Integer> &length,
                              const std::shared_ptr<Number> &from,
                              const std::shared_ptr<Number> &to,
                              const std::shared_ptr<Number> &start,
                              const std::shared_ptr<Unit> &unit,
                              const std::shared_ptr<Double> &abstol);
  AssignedDefinition(const AssignedDefinition &obj);

  virtual ~AssignedDefinition() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::AssignedDefinition
   * \return true as object is of type ast::AssignedDefinition
   */
  bool is_assigned_definition() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  AssignedDefinition *clone() const override {
    return new AssignedDefinition(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::ASSIGNED_DEFINITION
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::ASSIGNED_DEFINITION;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "AssignedDefinition"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "AssignedDefinition";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<AssignedDefinition>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const AssignedDefinition>(
        shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return name of the node
   *
   * Some ast nodes have a member marked designated as node name. For example,
   * in case of this ast::Identifier has name designated as a
   * node name.
   *
   * @return name of the node as std::string
   *
   * \sa Ast::get_node_type_name
   */
  std::string get_node_name() const override;

  /**
   * \brief Getter for member variable \ref AssignedDefinition.name
   */
  const std::shared_ptr<Identifier> &get_name() const noexcept { return name; }

  /**
   * \brief Getter for member variable \ref AssignedDefinition.length
   */
  const std::shared_ptr<Integer> &get_length() const noexcept { return length; }

  /**
   * \brief Getter for member variable \ref AssignedDefinition.from
   */
  const std::shared_ptr<Number> &get_from() const noexcept { return from; }

  /**
   * \brief Getter for member variable \ref AssignedDefinition.to
   */
  const std::shared_ptr<Number> &get_to() const noexcept { return to; }

  /**
   * \brief Getter for member variable \ref AssignedDefinition.start
   */
  const std::shared_ptr<Number> &get_start() const noexcept { return start; }

  /**
   * \brief Getter for member variable \ref AssignedDefinition.unit
   */
  const std::shared_ptr<Unit> &get_unit() const noexcept { return unit; }

  /**
   * \brief Getter for member variable \ref AssignedDefinition.abstol
   */
  const std::shared_ptr<Double> &get_abstol() const noexcept { return abstol; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref AssignedDefinition.name (rvalue
   * reference)
   */
  void set_name(std::shared_ptr<Identifier> &&name);

  /**
   * \brief Setter for member variable \ref AssignedDefinition.name
   */
  void set_name(const std::shared_ptr<Identifier> &name);

  /**
   * \brief Setter for member variable \ref AssignedDefinition.length (rvalue
   * reference)
   */
  void set_length(std::shared_ptr<Integer> &&length);

  /**
   * \brief Setter for member variable \ref AssignedDefinition.length
   */
  void set_length(const std::shared_ptr<Integer> &length);

  /**
   * \brief Setter for member variable \ref AssignedDefinition.from (rvalue
   * reference)
   */
  void set_from(std::shared_ptr<Number> &&from);

  /**
   * \brief Setter for member variable \ref AssignedDefinition.from
   */
  void set_from(const std::shared_ptr<Number> &from);

  /**
   * \brief Setter for member variable \ref AssignedDefinition.to (rvalue
   * reference)
   */
  void set_to(std::shared_ptr<Number> &&to);

  /**
   * \brief Setter for member variable \ref AssignedDefinition.to
   */
  void set_to(const std::shared_ptr<Number> &to);

  /**
   * \brief Setter for member variable \ref AssignedDefinition.start (rvalue
   * reference)
   */
  void set_start(std::shared_ptr<Number> &&start);

  /**
   * \brief Setter for member variable \ref AssignedDefinition.start
   */
  void set_start(const std::shared_ptr<Number> &start);

  /**
   * \brief Setter for member variable \ref AssignedDefinition.unit (rvalue
   * reference)
   */
  void set_unit(std::shared_ptr<Unit> &&unit);

  /**
   * \brief Setter for member variable \ref AssignedDefinition.unit
   */
  void set_unit(const std::shared_ptr<Unit> &unit);

  /**
   * \brief Setter for member variable \ref AssignedDefinition.abstol (rvalue
   * reference)
   */
  void set_abstol(std::shared_ptr<Double> &&abstol);

  /**
   * \brief Setter for member variable \ref AssignedDefinition.abstol
   */
  void set_abstol(const std::shared_ptr<Double> &abstol);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_ASSIGNED_DEFINITION_HPP
#ifndef NMODL_AST_PLOT_DECLARATION_HPP
#define NMODL_AST_PLOT_DECLARATION_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class PlotDeclaration : public Statement {
private:
  /// TODO
  PlotVarVector variables;
  /// TODO
  std::shared_ptr<PlotVar> name;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit PlotDeclaration(PlotVarVector variables, PlotVar *name);
  explicit PlotDeclaration(const PlotVarVector &variables,
                           const std::shared_ptr<PlotVar> &name);
  PlotDeclaration(const PlotDeclaration &obj);

  virtual ~PlotDeclaration() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::PlotDeclaration
   * \return true as object is of type ast::PlotDeclaration
   */
  bool is_plot_declaration() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  PlotDeclaration *clone() const override { return new PlotDeclaration(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::PLOT_DECLARATION
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::PLOT_DECLARATION;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "PlotDeclaration"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "PlotDeclaration";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "PLOT "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "PLOT "; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<PlotDeclaration>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const PlotDeclaration>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref PlotDeclaration.variables
   */
  const PlotVarVector &get_variables() const noexcept { return variables; }

  /**
   * \brief Getter for member variable \ref PlotDeclaration.name
   */
  const std::shared_ptr<PlotVar> &get_name() const noexcept { return name; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref PlotDeclaration.variables (rvalue
   * reference)
   */
  void set_variables(PlotVarVector &&variables);

  /**
   * \brief Setter for member variable \ref PlotDeclaration.variables
   */
  void set_variables(const PlotVarVector &variables);

  /**
   * \brief Setter for member variable \ref PlotDeclaration.name (rvalue
   * reference)
   */
  void set_name(std::shared_ptr<PlotVar> &&name);

  /**
   * \brief Setter for member variable \ref PlotDeclaration.name
   */
  void set_name(const std::shared_ptr<PlotVar> &name);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_PLOT_DECLARATION_HPP
#ifndef NMODL_AST_CONDUCTANCE_HINT_HPP
#define NMODL_AST_CONDUCTANCE_HINT_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents `CONDUCTANCE` statement in NMODL
 *
 * If `I/V` relation in the `BREAKPOINT` block is ohomic then one can
 * specify `CONDUCTANCE` hint for optimised code generation:
 *
 * \code{.mod}
 *     CONDUCTANCE g USEION I
 * \endcode
 *
 * \sa nmodl::visitor::SympyConductanceVisitor
 *
 */
class ConductanceHint : public Statement {
private:
  /// Conductance variable
  std::shared_ptr<Name> conductance;
  /// Ion name
  std::shared_ptr<Name> ion;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit ConductanceHint(Name *conductance, Name *ion);
  explicit ConductanceHint(const std::shared_ptr<Name> &conductance,
                           const std::shared_ptr<Name> &ion);
  ConductanceHint(const ConductanceHint &obj);

  virtual ~ConductanceHint() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::ConductanceHint
   * \return true as object is of type ast::ConductanceHint
   */
  bool is_conductance_hint() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  ConductanceHint *clone() const override { return new ConductanceHint(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::CONDUCTANCE_HINT
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::CONDUCTANCE_HINT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "ConductanceHint"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "ConductanceHint";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "CONDUCTANCE "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override {
    return "CONDUCTANCE ";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<ConductanceHint>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const ConductanceHint>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref ConductanceHint.conductance
   */
  const std::shared_ptr<Name> &get_conductance() const noexcept {
    return conductance;
  }

  /**
   * \brief Getter for member variable \ref ConductanceHint.ion
   */
  const std::shared_ptr<Name> &get_ion() const noexcept { return ion; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref ConductanceHint.conductance (rvalue
   * reference)
   */
  void set_conductance(std::shared_ptr<Name> &&conductance);

  /**
   * \brief Setter for member variable \ref ConductanceHint.conductance
   */
  void set_conductance(const std::shared_ptr<Name> &conductance);

  /**
   * \brief Setter for member variable \ref ConductanceHint.ion (rvalue
   * reference)
   */
  void set_ion(std::shared_ptr<Name> &&ion);

  /**
   * \brief Setter for member variable \ref ConductanceHint.ion
   */
  void set_ion(const std::shared_ptr<Name> &ion);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_CONDUCTANCE_HINT_HPP
#ifndef NMODL_AST_EXPRESSION_STATEMENT_HPP
#define NMODL_AST_EXPRESSION_STATEMENT_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class ExpressionStatement : public Statement {
private:
  /// TODO
  std::shared_ptr<Expression> expression;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit ExpressionStatement(Expression *expression);
  explicit ExpressionStatement(const std::shared_ptr<Expression> &expression);
  ExpressionStatement(const ExpressionStatement &obj);

  virtual ~ExpressionStatement() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::ExpressionStatement
   * \return true as object is of type ast::ExpressionStatement
   */
  bool is_expression_statement() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  ExpressionStatement *clone() const override {
    return new ExpressionStatement(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::EXPRESSION_STATEMENT
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::EXPRESSION_STATEMENT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "ExpressionStatement"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "ExpressionStatement";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<ExpressionStatement>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const ExpressionStatement>(
        shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref ExpressionStatement.expression
   */
  const std::shared_ptr<Expression> &get_expression() const noexcept {
    return expression;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref ExpressionStatement.expression
   * (rvalue reference)
   */
  void set_expression(std::shared_ptr<Expression> &&expression);

  /**
   * \brief Setter for member variable \ref ExpressionStatement.expression
   */
  void set_expression(const std::shared_ptr<Expression> &expression);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_EXPRESSION_STATEMENT_HPP
#ifndef NMODL_AST_PROTECT_STATEMENT_HPP
#define NMODL_AST_PROTECT_STATEMENT_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class ProtectStatement : public Statement {
private:
  /// TODO
  std::shared_ptr<Expression> expression;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit ProtectStatement(Expression *expression);
  explicit ProtectStatement(const std::shared_ptr<Expression> &expression);
  ProtectStatement(const ProtectStatement &obj);

  virtual ~ProtectStatement() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::ProtectStatement
   * \return true as object is of type ast::ProtectStatement
   */
  bool is_protect_statement() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  ProtectStatement *clone() const override {
    return new ProtectStatement(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::PROTECT_STATEMENT
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::PROTECT_STATEMENT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "ProtectStatement"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "ProtectStatement";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "PROTECT "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "PROTECT "; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<ProtectStatement>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const ProtectStatement>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref ProtectStatement.expression
   */
  const std::shared_ptr<Expression> &get_expression() const noexcept {
    return expression;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref ProtectStatement.expression (rvalue
   * reference)
   */
  void set_expression(std::shared_ptr<Expression> &&expression);

  /**
   * \brief Setter for member variable \ref ProtectStatement.expression
   */
  void set_expression(const std::shared_ptr<Expression> &expression);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_PROTECT_STATEMENT_HPP
#ifndef NMODL_AST_FROM_STATEMENT_HPP
#define NMODL_AST_FROM_STATEMENT_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class FromStatement : public Statement {
private:
  /// TODO
  std::shared_ptr<Name> name;
  /// TODO
  std::shared_ptr<Expression> from;
  /// TODO
  std::shared_ptr<Expression> to;
  /// TODO
  std::shared_ptr<Expression> increment;
  /// TODO
  std::shared_ptr<StatementBlock> statement_block;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit FromStatement(Name *name, Expression *from, Expression *to,
                         Expression *increment,
                         StatementBlock *statement_block);
  explicit FromStatement(
      const std::shared_ptr<Name> &name,
      const std::shared_ptr<Expression> &from,
      const std::shared_ptr<Expression> &to,
      const std::shared_ptr<Expression> &increment,
      const std::shared_ptr<StatementBlock> &statement_block);
  FromStatement(const FromStatement &obj);

  virtual ~FromStatement() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::FromStatement
   * \return true as object is of type ast::FromStatement
   */
  bool is_from_statement() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  FromStatement *clone() const override { return new FromStatement(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::FROM_STATEMENT
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::FROM_STATEMENT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "FromStatement"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "FromStatement";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "FROM "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "FROM "; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<FromStatement>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const FromStatement>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return name of the node
   *
   * Some ast nodes have a member marked designated as node name. For example,
   * in case of this ast::Name has name designated as a
   * node name.
   *
   * @return name of the node as std::string
   *
   * \sa Ast::get_node_type_name
   */
  std::string get_node_name() const override;

  /**
   * \brief Getter for member variable \ref FromStatement.name
   */
  const std::shared_ptr<Name> &get_name() const noexcept { return name; }

  /**
   * \brief Getter for member variable \ref FromStatement.from
   */
  const std::shared_ptr<Expression> &get_from() const noexcept { return from; }

  /**
   * \brief Getter for member variable \ref FromStatement.to
   */
  const std::shared_ptr<Expression> &get_to() const noexcept { return to; }

  /**
   * \brief Getter for member variable \ref FromStatement.increment
   */
  const std::shared_ptr<Expression> &get_increment() const noexcept {
    return increment;
  }

  /**
   * \brief Getter for member variable \ref FromStatement.statement_block
   */
  const std::shared_ptr<StatementBlock> &get_statement_block() const
      noexcept override {
    return statement_block;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref FromStatement.name (rvalue
   * reference)
   */
  void set_name(std::shared_ptr<Name> &&name);

  /**
   * \brief Setter for member variable \ref FromStatement.name
   */
  void set_name(const std::shared_ptr<Name> &name);

  /**
   * \brief Setter for member variable \ref FromStatement.from (rvalue
   * reference)
   */
  void set_from(std::shared_ptr<Expression> &&from);

  /**
   * \brief Setter for member variable \ref FromStatement.from
   */
  void set_from(const std::shared_ptr<Expression> &from);

  /**
   * \brief Setter for member variable \ref FromStatement.to (rvalue reference)
   */
  void set_to(std::shared_ptr<Expression> &&to);

  /**
   * \brief Setter for member variable \ref FromStatement.to
   */
  void set_to(const std::shared_ptr<Expression> &to);

  /**
   * \brief Setter for member variable \ref FromStatement.increment (rvalue
   * reference)
   */
  void set_increment(std::shared_ptr<Expression> &&increment);

  /**
   * \brief Setter for member variable \ref FromStatement.increment
   */
  void set_increment(const std::shared_ptr<Expression> &increment);

  /**
   * \brief Setter for member variable \ref FromStatement.statement_block
   * (rvalue reference)
   */
  void set_statement_block(std::shared_ptr<StatementBlock> &&statement_block);

  /**
   * \brief Setter for member variable \ref FromStatement.statement_block
   */
  void
  set_statement_block(const std::shared_ptr<StatementBlock> &statement_block);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_FROM_STATEMENT_HPP
#ifndef NMODL_AST_FOR_ALL_STATEMENT_HPP
#define NMODL_AST_FOR_ALL_STATEMENT_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class ForAllStatement : public Statement {
private:
  /// TODO
  std::shared_ptr<Name> name;
  /// TODO
  std::shared_ptr<StatementBlock> statement_block;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit ForAllStatement(Name *name, StatementBlock *statement_block);
  explicit ForAllStatement(
      const std::shared_ptr<Name> &name,
      const std::shared_ptr<StatementBlock> &statement_block);
  ForAllStatement(const ForAllStatement &obj);

  virtual ~ForAllStatement() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::ForAllStatement
   * \return true as object is of type ast::ForAllStatement
   */
  bool is_for_all_statement() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  ForAllStatement *clone() const override { return new ForAllStatement(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::FOR_ALL_STATEMENT
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::FOR_ALL_STATEMENT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "ForAllStatement"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "ForAllStatement";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "FORALL "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "FORALL "; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<ForAllStatement>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const ForAllStatement>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref ForAllStatement.name
   */
  const std::shared_ptr<Name> &get_name() const noexcept { return name; }

  /**
   * \brief Getter for member variable \ref ForAllStatement.statement_block
   */
  const std::shared_ptr<StatementBlock> &get_statement_block() const
      noexcept override {
    return statement_block;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref ForAllStatement.name (rvalue
   * reference)
   */
  void set_name(std::shared_ptr<Name> &&name);

  /**
   * \brief Setter for member variable \ref ForAllStatement.name
   */
  void set_name(const std::shared_ptr<Name> &name);

  /**
   * \brief Setter for member variable \ref ForAllStatement.statement_block
   * (rvalue reference)
   */
  void set_statement_block(std::shared_ptr<StatementBlock> &&statement_block);

  /**
   * \brief Setter for member variable \ref ForAllStatement.statement_block
   */
  void
  set_statement_block(const std::shared_ptr<StatementBlock> &statement_block);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_FOR_ALL_STATEMENT_HPP
#ifndef NMODL_AST_WHILE_STATEMENT_HPP
#define NMODL_AST_WHILE_STATEMENT_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class WhileStatement : public Statement {
private:
  /// TODO
  std::shared_ptr<Expression> condition;
  /// TODO
  std::shared_ptr<StatementBlock> statement_block;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit WhileStatement(Expression *condition,
                          StatementBlock *statement_block);
  explicit WhileStatement(
      const std::shared_ptr<Expression> &condition,
      const std::shared_ptr<StatementBlock> &statement_block);
  WhileStatement(const WhileStatement &obj);

  virtual ~WhileStatement() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::WhileStatement
   * \return true as object is of type ast::WhileStatement
   */
  bool is_while_statement() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  WhileStatement *clone() const override { return new WhileStatement(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::WHILE_STATEMENT
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::WHILE_STATEMENT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "WhileStatement"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "WhileStatement";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "WHILE "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "WHILE "; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<WhileStatement>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const WhileStatement>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref WhileStatement.condition
   */
  const std::shared_ptr<Expression> &get_condition() const noexcept {
    return condition;
  }

  /**
   * \brief Getter for member variable \ref WhileStatement.statement_block
   */
  const std::shared_ptr<StatementBlock> &get_statement_block() const
      noexcept override {
    return statement_block;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref WhileStatement.condition (rvalue
   * reference)
   */
  void set_condition(std::shared_ptr<Expression> &&condition);

  /**
   * \brief Setter for member variable \ref WhileStatement.condition
   */
  void set_condition(const std::shared_ptr<Expression> &condition);

  /**
   * \brief Setter for member variable \ref WhileStatement.statement_block
   * (rvalue reference)
   */
  void set_statement_block(std::shared_ptr<StatementBlock> &&statement_block);

  /**
   * \brief Setter for member variable \ref WhileStatement.statement_block
   */
  void
  set_statement_block(const std::shared_ptr<StatementBlock> &statement_block);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_WHILE_STATEMENT_HPP
#ifndef NMODL_AST_IF_STATEMENT_HPP
#define NMODL_AST_IF_STATEMENT_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class IfStatement : public Statement {
private:
  /// TODO
  std::shared_ptr<Expression> condition;
  /// TODO
  std::shared_ptr<StatementBlock> statement_block;
  /// TODO
  ElseIfStatementVector elseifs;
  /// TODO
  std::shared_ptr<ElseStatement> elses;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit IfStatement(Expression *condition, StatementBlock *statement_block,
                       ElseIfStatementVector elseifs, ElseStatement *elses);
  explicit IfStatement(const std::shared_ptr<Expression> &condition,
                       const std::shared_ptr<StatementBlock> &statement_block,
                       const ElseIfStatementVector &elseifs,
                       const std::shared_ptr<ElseStatement> &elses);
  IfStatement(const IfStatement &obj);

  virtual ~IfStatement() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::IfStatement
   * \return true as object is of type ast::IfStatement
   */
  bool is_if_statement() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  IfStatement *clone() const override { return new IfStatement(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::IF_STATEMENT
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::IF_STATEMENT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "IfStatement"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "IfStatement";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "IF "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "IF "; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<IfStatement>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const IfStatement>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref IfStatement.condition
   */
  const std::shared_ptr<Expression> &get_condition() const noexcept {
    return condition;
  }

  /**
   * \brief Getter for member variable \ref IfStatement.statement_block
   */
  const std::shared_ptr<StatementBlock> &get_statement_block() const
      noexcept override {
    return statement_block;
  }

  /**
   * \brief Getter for member variable \ref IfStatement.elseifs
   */
  const ElseIfStatementVector &get_elseifs() const noexcept { return elseifs; }

  /**
   * \brief Getter for member variable \ref IfStatement.elses
   */
  const std::shared_ptr<ElseStatement> &get_elses() const noexcept {
    return elses;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref IfStatement.condition (rvalue
   * reference)
   */
  void set_condition(std::shared_ptr<Expression> &&condition);

  /**
   * \brief Setter for member variable \ref IfStatement.condition
   */
  void set_condition(const std::shared_ptr<Expression> &condition);

  /**
   * \brief Setter for member variable \ref IfStatement.statement_block (rvalue
   * reference)
   */
  void set_statement_block(std::shared_ptr<StatementBlock> &&statement_block);

  /**
   * \brief Setter for member variable \ref IfStatement.statement_block
   */
  void
  set_statement_block(const std::shared_ptr<StatementBlock> &statement_block);

  /**
   * \brief Setter for member variable \ref IfStatement.elseifs (rvalue
   * reference)
   */
  void set_elseifs(ElseIfStatementVector &&elseifs);

  /**
   * \brief Setter for member variable \ref IfStatement.elseifs
   */
  void set_elseifs(const ElseIfStatementVector &elseifs);

  /**
   * \brief Setter for member variable \ref IfStatement.elses (rvalue reference)
   */
  void set_elses(std::shared_ptr<ElseStatement> &&elses);

  /**
   * \brief Setter for member variable \ref IfStatement.elses
   */
  void set_elses(const std::shared_ptr<ElseStatement> &elses);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_IF_STATEMENT_HPP
#ifndef NMODL_AST_ELSE_IF_STATEMENT_HPP
#define NMODL_AST_ELSE_IF_STATEMENT_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class ElseIfStatement : public Statement {
private:
  /// TODO
  std::shared_ptr<Expression> condition;
  /// TODO
  std::shared_ptr<StatementBlock> statement_block;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit ElseIfStatement(Expression *condition,
                           StatementBlock *statement_block);
  explicit ElseIfStatement(
      const std::shared_ptr<Expression> &condition,
      const std::shared_ptr<StatementBlock> &statement_block);
  ElseIfStatement(const ElseIfStatement &obj);

  virtual ~ElseIfStatement() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::ElseIfStatement
   * \return true as object is of type ast::ElseIfStatement
   */
  bool is_else_if_statement() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  ElseIfStatement *clone() const override { return new ElseIfStatement(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::ELSE_IF_STATEMENT
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::ELSE_IF_STATEMENT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "ElseIfStatement"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "ElseIfStatement";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. " ELSE IF "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return " ELSE IF "; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<ElseIfStatement>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const ElseIfStatement>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref ElseIfStatement.condition
   */
  const std::shared_ptr<Expression> &get_condition() const noexcept {
    return condition;
  }

  /**
   * \brief Getter for member variable \ref ElseIfStatement.statement_block
   */
  const std::shared_ptr<StatementBlock> &get_statement_block() const
      noexcept override {
    return statement_block;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref ElseIfStatement.condition (rvalue
   * reference)
   */
  void set_condition(std::shared_ptr<Expression> &&condition);

  /**
   * \brief Setter for member variable \ref ElseIfStatement.condition
   */
  void set_condition(const std::shared_ptr<Expression> &condition);

  /**
   * \brief Setter for member variable \ref ElseIfStatement.statement_block
   * (rvalue reference)
   */
  void set_statement_block(std::shared_ptr<StatementBlock> &&statement_block);

  /**
   * \brief Setter for member variable \ref ElseIfStatement.statement_block
   */
  void
  set_statement_block(const std::shared_ptr<StatementBlock> &statement_block);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_ELSE_IF_STATEMENT_HPP
#ifndef NMODL_AST_ELSE_STATEMENT_HPP
#define NMODL_AST_ELSE_STATEMENT_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class ElseStatement : public Statement {
private:
  /// TODO
  std::shared_ptr<StatementBlock> statement_block;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit ElseStatement(StatementBlock *statement_block);
  explicit ElseStatement(
      const std::shared_ptr<StatementBlock> &statement_block);
  ElseStatement(const ElseStatement &obj);

  virtual ~ElseStatement() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::ElseStatement
   * \return true as object is of type ast::ElseStatement
   */
  bool is_else_statement() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  ElseStatement *clone() const override { return new ElseStatement(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::ELSE_STATEMENT
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::ELSE_STATEMENT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "ElseStatement"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "ElseStatement";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. " ELSE "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return " ELSE "; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<ElseStatement>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const ElseStatement>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref ElseStatement.statement_block
   */
  const std::shared_ptr<StatementBlock> &get_statement_block() const
      noexcept override {
    return statement_block;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref ElseStatement.statement_block
   * (rvalue reference)
   */
  void set_statement_block(std::shared_ptr<StatementBlock> &&statement_block);

  /**
   * \brief Setter for member variable \ref ElseStatement.statement_block
   */
  void
  set_statement_block(const std::shared_ptr<StatementBlock> &statement_block);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_ELSE_STATEMENT_HPP
#ifndef NMODL_AST_PARTIAL_EQUATION_HPP
#define NMODL_AST_PARTIAL_EQUATION_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class PartialEquation : public Statement {
private:
  /// TODO
  std::shared_ptr<PrimeName> prime;
  /// TODO
  std::shared_ptr<Name> name1;
  /// TODO
  std::shared_ptr<Name> name2;
  /// TODO
  std::shared_ptr<Name> name3;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit PartialEquation(PrimeName *prime, Name *name1, Name *name2,
                           Name *name3);
  explicit PartialEquation(const std::shared_ptr<PrimeName> &prime,
                           const std::shared_ptr<Name> &name1,
                           const std::shared_ptr<Name> &name2,
                           const std::shared_ptr<Name> &name3);
  PartialEquation(const PartialEquation &obj);

  virtual ~PartialEquation() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::PartialEquation
   * \return true as object is of type ast::PartialEquation
   */
  bool is_partial_equation() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  PartialEquation *clone() const override { return new PartialEquation(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::PARTIAL_EQUATION
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::PARTIAL_EQUATION;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "PartialEquation"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "PartialEquation";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<PartialEquation>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const PartialEquation>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref PartialEquation.prime
   */
  const std::shared_ptr<PrimeName> &get_prime() const noexcept { return prime; }

  /**
   * \brief Getter for member variable \ref PartialEquation.name1
   */
  const std::shared_ptr<Name> &get_name1() const noexcept { return name1; }

  /**
   * \brief Getter for member variable \ref PartialEquation.name2
   */
  const std::shared_ptr<Name> &get_name2() const noexcept { return name2; }

  /**
   * \brief Getter for member variable \ref PartialEquation.name3
   */
  const std::shared_ptr<Name> &get_name3() const noexcept { return name3; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref PartialEquation.prime (rvalue
   * reference)
   */
  void set_prime(std::shared_ptr<PrimeName> &&prime);

  /**
   * \brief Setter for member variable \ref PartialEquation.prime
   */
  void set_prime(const std::shared_ptr<PrimeName> &prime);

  /**
   * \brief Setter for member variable \ref PartialEquation.name1 (rvalue
   * reference)
   */
  void set_name1(std::shared_ptr<Name> &&name1);

  /**
   * \brief Setter for member variable \ref PartialEquation.name1
   */
  void set_name1(const std::shared_ptr<Name> &name1);

  /**
   * \brief Setter for member variable \ref PartialEquation.name2 (rvalue
   * reference)
   */
  void set_name2(std::shared_ptr<Name> &&name2);

  /**
   * \brief Setter for member variable \ref PartialEquation.name2
   */
  void set_name2(const std::shared_ptr<Name> &name2);

  /**
   * \brief Setter for member variable \ref PartialEquation.name3 (rvalue
   * reference)
   */
  void set_name3(std::shared_ptr<Name> &&name3);

  /**
   * \brief Setter for member variable \ref PartialEquation.name3
   */
  void set_name3(const std::shared_ptr<Name> &name3);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_PARTIAL_EQUATION_HPP
#ifndef NMODL_AST_PARTIAL_BOUNDARY_HPP
#define NMODL_AST_PARTIAL_BOUNDARY_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class PartialBoundary : public Statement {
private:
  /// TODO
  std::shared_ptr<Name> del;
  /// TODO
  std::shared_ptr<Identifier> name;
  /// TODO
  std::shared_ptr<FirstLastTypeIndex> index;
  /// TODO
  std::shared_ptr<Expression> expression;
  /// TODO
  std::shared_ptr<Name> name1;
  /// TODO
  std::shared_ptr<Name> del2;
  /// TODO
  std::shared_ptr<Name> name2;
  /// TODO
  std::shared_ptr<Name> name3;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit PartialBoundary(Name *del, Identifier *name,
                           FirstLastTypeIndex *index, Expression *expression,
                           Name *name1, Name *del2, Name *name2, Name *name3);
  explicit PartialBoundary(const std::shared_ptr<Name> &del,
                           const std::shared_ptr<Identifier> &name,
                           const std::shared_ptr<FirstLastTypeIndex> &index,
                           const std::shared_ptr<Expression> &expression,
                           const std::shared_ptr<Name> &name1,
                           const std::shared_ptr<Name> &del2,
                           const std::shared_ptr<Name> &name2,
                           const std::shared_ptr<Name> &name3);
  PartialBoundary(const PartialBoundary &obj);

  virtual ~PartialBoundary() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::PartialBoundary
   * \return true as object is of type ast::PartialBoundary
   */
  bool is_partial_boundary() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  PartialBoundary *clone() const override { return new PartialBoundary(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::PARTIAL_BOUNDARY
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::PARTIAL_BOUNDARY;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "PartialBoundary"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "PartialBoundary";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "~ "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "~ "; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<PartialBoundary>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const PartialBoundary>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref PartialBoundary.del
   */
  const std::shared_ptr<Name> &get_del() const noexcept { return del; }

  /**
   * \brief Getter for member variable \ref PartialBoundary.name
   */
  const std::shared_ptr<Identifier> &get_name() const noexcept { return name; }

  /**
   * \brief Getter for member variable \ref PartialBoundary.index
   */
  const std::shared_ptr<FirstLastTypeIndex> &get_index() const noexcept {
    return index;
  }

  /**
   * \brief Getter for member variable \ref PartialBoundary.expression
   */
  const std::shared_ptr<Expression> &get_expression() const noexcept {
    return expression;
  }

  /**
   * \brief Getter for member variable \ref PartialBoundary.name1
   */
  const std::shared_ptr<Name> &get_name1() const noexcept { return name1; }

  /**
   * \brief Getter for member variable \ref PartialBoundary.del2
   */
  const std::shared_ptr<Name> &get_del2() const noexcept { return del2; }

  /**
   * \brief Getter for member variable \ref PartialBoundary.name2
   */
  const std::shared_ptr<Name> &get_name2() const noexcept { return name2; }

  /**
   * \brief Getter for member variable \ref PartialBoundary.name3
   */
  const std::shared_ptr<Name> &get_name3() const noexcept { return name3; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref PartialBoundary.del (rvalue
   * reference)
   */
  void set_del(std::shared_ptr<Name> &&del);

  /**
   * \brief Setter for member variable \ref PartialBoundary.del
   */
  void set_del(const std::shared_ptr<Name> &del);

  /**
   * \brief Setter for member variable \ref PartialBoundary.name (rvalue
   * reference)
   */
  void set_name(std::shared_ptr<Identifier> &&name);

  /**
   * \brief Setter for member variable \ref PartialBoundary.name
   */
  void set_name(const std::shared_ptr<Identifier> &name);

  /**
   * \brief Setter for member variable \ref PartialBoundary.index (rvalue
   * reference)
   */
  void set_index(std::shared_ptr<FirstLastTypeIndex> &&index);

  /**
   * \brief Setter for member variable \ref PartialBoundary.index
   */
  void set_index(const std::shared_ptr<FirstLastTypeIndex> &index);

  /**
   * \brief Setter for member variable \ref PartialBoundary.expression (rvalue
   * reference)
   */
  void set_expression(std::shared_ptr<Expression> &&expression);

  /**
   * \brief Setter for member variable \ref PartialBoundary.expression
   */
  void set_expression(const std::shared_ptr<Expression> &expression);

  /**
   * \brief Setter for member variable \ref PartialBoundary.name1 (rvalue
   * reference)
   */
  void set_name1(std::shared_ptr<Name> &&name1);

  /**
   * \brief Setter for member variable \ref PartialBoundary.name1
   */
  void set_name1(const std::shared_ptr<Name> &name1);

  /**
   * \brief Setter for member variable \ref PartialBoundary.del2 (rvalue
   * reference)
   */
  void set_del2(std::shared_ptr<Name> &&del2);

  /**
   * \brief Setter for member variable \ref PartialBoundary.del2
   */
  void set_del2(const std::shared_ptr<Name> &del2);

  /**
   * \brief Setter for member variable \ref PartialBoundary.name2 (rvalue
   * reference)
   */
  void set_name2(std::shared_ptr<Name> &&name2);

  /**
   * \brief Setter for member variable \ref PartialBoundary.name2
   */
  void set_name2(const std::shared_ptr<Name> &name2);

  /**
   * \brief Setter for member variable \ref PartialBoundary.name3 (rvalue
   * reference)
   */
  void set_name3(std::shared_ptr<Name> &&name3);

  /**
   * \brief Setter for member variable \ref PartialBoundary.name3
   */
  void set_name3(const std::shared_ptr<Name> &name3);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_PARTIAL_BOUNDARY_HPP
#ifndef NMODL_AST_WATCH_STATEMENT_HPP
#define NMODL_AST_WATCH_STATEMENT_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represent WATCH statement in NMODL
 *
 *
 */
class WatchStatement : public Statement {
private:
  /// Vector of watch statements
  WatchVector statements;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit WatchStatement(WatchVector statements);
  WatchStatement(const WatchStatement &obj);

  virtual ~WatchStatement() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::WatchStatement
   * \return true as object is of type ast::WatchStatement
   */
  bool is_watch_statement() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  WatchStatement *clone() const override { return new WatchStatement(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::WATCH_STATEMENT
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::WATCH_STATEMENT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "WatchStatement"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "WatchStatement";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "WATCH "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "WATCH "; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<WatchStatement>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const WatchStatement>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Add member to statements by raw pointer
   */
  void emplace_back_watch(Watch *n) {
    statements.emplace_back(n);

    // set parents
    n->set_parent(this);
  }

  /**
   * \brief Add member to statements by shared_ptr
   */
  void emplace_back_watch(std::shared_ptr<Watch> n) {
    statements.emplace_back(n);
    // set parents
    n->set_parent(this);
  }

  /**
   * \brief Erase member to statements
   */
  WatchVector::const_iterator erase_watch(WatchVector::const_iterator first) {
    auto first_it = const_iter_cast(statements, first);
    return statements.erase(first_it);
  }
  /**
   * \brief Erase members to statements
   */
  WatchVector::const_iterator erase_watch(WatchVector::const_iterator first,
                                          WatchVector::const_iterator last) {
    auto first_it = const_iter_cast(statements, first);
    auto last_it = const_iter_cast(statements, last);
    return statements.erase(first_it, last_it);
  }
  /**
   * \brief Erase non-consecutive members to statements
   *
   * loosely following the cpp reference of remove_if
   */
  size_t erase_watch(std::unordered_set<Watch *> &to_be_erased) {
    auto first = statements.begin();
    auto last = statements.end();
    auto result = first;

    while (first != last) {
      // automatically erase dangling pointers from the uset while
      // looking for them to erase them in the vector
      if (to_be_erased.erase(first->get()) == 0) {
        reset_watch(result, *first);
        ++result;
      }
      ++first;
    }

    size_t out = last - result;
    erase_watch(result, last);

    return out;
  }

  /**
   * \brief Insert member to statements
   */
  WatchVector::const_iterator insert_watch(WatchVector::const_iterator position,
                                           const std::shared_ptr<Watch> &n) {
    n->set_parent(this);
    auto pos_it = const_iter_cast(statements, position);
    return statements.insert(pos_it, n);
  }
  /**
   * \brief Insert members to statements
   */
  template <class NodeType, class InputIterator>
  void insert_watch(WatchVector::const_iterator position, NodeType &to,
                    InputIterator first, InputIterator last) {

    for (auto it = first; it != last; ++it) {
      auto &n = *it;
      // set parents
      n->set_parent(this);
    }
    auto pos_it = const_iter_cast(statements, position);
    auto first_it = const_iter_cast(to, first);
    auto last_it = const_iter_cast(to, last);
    statements.insert(pos_it, first_it, last_it);
  }

  /**
   * \brief Reset member to statements
   */
  void reset_watch(WatchVector::const_iterator position, Watch *n) {
    // set parents
    n->set_parent(this);

    statements[position - statements.begin()].reset(n);
  }

  /**
   * \brief Reset member to statements
   */
  void reset_watch(WatchVector::const_iterator position,
                   std::shared_ptr<Watch> n) {
    // set parents
    n->set_parent(this);

    statements[position - statements.begin()] = n;
  }

  /**
   * \brief Getter for member variable \ref WatchStatement.statements
   */
  const WatchVector &get_statements() const noexcept { return statements; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref WatchStatement.statements (rvalue
   * reference)
   */
  void set_statements(WatchVector &&statements);

  /**
   * \brief Setter for member variable \ref WatchStatement.statements
   */
  void set_statements(const WatchVector &statements);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_WATCH_STATEMENT_HPP
#ifndef NMODL_AST_MUTEX_LOCK_HPP
#define NMODL_AST_MUTEX_LOCK_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represent MUTEXLOCK statement in NMODL
 *
 *
 */
class MutexLock : public Statement {
private:
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  virtual ~MutexLock() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::MutexLock
   * \return true as object is of type ast::MutexLock
   */
  bool is_mutex_lock() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  MutexLock *clone() const override { return new MutexLock(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::MUTEX_LOCK
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::MUTEX_LOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "MutexLock"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "MutexLock";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "MUTEXLOCK"
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "MUTEXLOCK"; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<MutexLock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const MutexLock>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_MUTEX_LOCK_HPP
#ifndef NMODL_AST_MUTEX_UNLOCK_HPP
#define NMODL_AST_MUTEX_UNLOCK_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represent MUTEXUNLOCK statement in NMODL
 *
 *
 */
class MutexUnlock : public Statement {
private:
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  virtual ~MutexUnlock() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::MutexUnlock
   * \return true as object is of type ast::MutexUnlock
   */
  bool is_mutex_unlock() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  MutexUnlock *clone() const override { return new MutexUnlock(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::MUTEX_UNLOCK
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::MUTEX_UNLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "MutexUnlock"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "MutexUnlock";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "MUTEXUNLOCK"
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "MUTEXUNLOCK"; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<MutexUnlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const MutexUnlock>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_MUTEX_UNLOCK_HPP
#ifndef NMODL_AST_RESET_HPP
#define NMODL_AST_RESET_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represent RESET statement in NMODL
 *
 *
 */
class Reset : public Statement {
private:
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  virtual ~Reset() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::Reset
   * \return true as object is of type ast::Reset
   */
  bool is_reset() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  Reset *clone() const override { return new Reset(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::RESET
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::RESET;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Reset"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override { return "Reset"; }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "RESET"
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "RESET"; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Reset>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Reset>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_RESET_HPP
#ifndef NMODL_AST_SENS_HPP
#define NMODL_AST_SENS_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represent SENS statement in NMODL
 *
 *
 */
class Sens : public Statement {
private:
  /// TODO
  VarNameVector variables;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit Sens(VarNameVector variables);
  Sens(const Sens &obj);

  virtual ~Sens() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::Sens
   * \return true as object is of type ast::Sens
   */
  bool is_sens() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  Sens *clone() const override { return new Sens(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::SENS
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::SENS;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Sens"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override { return "Sens"; }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "SENS "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "SENS "; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Sens>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Sens>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref Sens.variables
   */
  const VarNameVector &get_variables() const noexcept { return variables; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref Sens.variables (rvalue reference)
   */
  void set_variables(VarNameVector &&variables);

  /**
   * \brief Setter for member variable \ref Sens.variables
   */
  void set_variables(const VarNameVector &variables);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_SENS_HPP
#ifndef NMODL_AST_CONSERVE_HPP
#define NMODL_AST_CONSERVE_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represent CONSERVE statement in NMODL
 *
 *
 */
class Conserve : public Statement {
private:
  /// TODO
  std::shared_ptr<Expression> react;
  /// TODO
  std::shared_ptr<Expression> expr;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit Conserve(Expression *react, Expression *expr);
  explicit Conserve(const std::shared_ptr<Expression> &react,
                    const std::shared_ptr<Expression> &expr);
  Conserve(const Conserve &obj);

  virtual ~Conserve() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::Conserve
   * \return true as object is of type ast::Conserve
   */
  bool is_conserve() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  Conserve *clone() const override { return new Conserve(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::CONSERVE
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::CONSERVE;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Conserve"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "Conserve";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "CONSERVE"
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "CONSERVE"; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Conserve>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Conserve>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref Conserve.react
   */
  const std::shared_ptr<Expression> &get_react() const noexcept {
    return react;
  }

  /**
   * \brief Getter for member variable \ref Conserve.expr
   */
  const std::shared_ptr<Expression> &get_expr() const noexcept { return expr; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref Conserve.react (rvalue reference)
   */
  void set_react(std::shared_ptr<Expression> &&react);

  /**
   * \brief Setter for member variable \ref Conserve.react
   */
  void set_react(const std::shared_ptr<Expression> &react);

  /**
   * \brief Setter for member variable \ref Conserve.expr (rvalue reference)
   */
  void set_expr(std::shared_ptr<Expression> &&expr);

  /**
   * \brief Setter for member variable \ref Conserve.expr
   */
  void set_expr(const std::shared_ptr<Expression> &expr);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_CONSERVE_HPP
#ifndef NMODL_AST_COMPARTMENT_HPP
#define NMODL_AST_COMPARTMENT_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represent COMPARTMENT statement in NMODL
 *
 *
 */
class Compartment : public Statement {
private:
  /// TODO
  std::shared_ptr<Name> name;
  /// TODO
  std::shared_ptr<Expression> expression;
  /// TODO
  NameVector names;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit Compartment(Name *name, Expression *expression, NameVector names);
  explicit Compartment(const std::shared_ptr<Name> &name,
                       const std::shared_ptr<Expression> &expression,
                       const NameVector &names);
  Compartment(const Compartment &obj);

  virtual ~Compartment() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::Compartment
   * \return true as object is of type ast::Compartment
   */
  bool is_compartment() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  Compartment *clone() const override { return new Compartment(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::COMPARTMENT
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::COMPARTMENT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Compartment"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "Compartment";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "COMPARTMENT"
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "COMPARTMENT"; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Compartment>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Compartment>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref Compartment.name
   */
  const std::shared_ptr<Name> &get_name() const noexcept { return name; }

  /**
   * \brief Getter for member variable \ref Compartment.expression
   */
  const std::shared_ptr<Expression> &get_expression() const noexcept {
    return expression;
  }

  /**
   * \brief Getter for member variable \ref Compartment.names
   */
  const NameVector &get_names() const noexcept { return names; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref Compartment.name (rvalue reference)
   */
  void set_name(std::shared_ptr<Name> &&name);

  /**
   * \brief Setter for member variable \ref Compartment.name
   */
  void set_name(const std::shared_ptr<Name> &name);

  /**
   * \brief Setter for member variable \ref Compartment.expression (rvalue
   * reference)
   */
  void set_expression(std::shared_ptr<Expression> &&expression);

  /**
   * \brief Setter for member variable \ref Compartment.expression
   */
  void set_expression(const std::shared_ptr<Expression> &expression);

  /**
   * \brief Setter for member variable \ref Compartment.names (rvalue reference)
   */
  void set_names(NameVector &&names);

  /**
   * \brief Setter for member variable \ref Compartment.names
   */
  void set_names(const NameVector &names);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_COMPARTMENT_HPP
#ifndef NMODL_AST_LON_DIFUSE_HPP
#define NMODL_AST_LON_DIFUSE_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represent LONGITUDINAL_DIFFUSION statement in NMODL
 *
 *
 */
class LonDifuse : public Statement {
private:
  /// TODO
  std::shared_ptr<Name> name;
  /// TODO
  std::shared_ptr<Expression> expression;
  /// TODO
  NameVector names;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit LonDifuse(Name *name, Expression *expression, NameVector names);
  explicit LonDifuse(const std::shared_ptr<Name> &name,
                     const std::shared_ptr<Expression> &expression,
                     const NameVector &names);
  LonDifuse(const LonDifuse &obj);

  virtual ~LonDifuse() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::LonDifuse
   * \return true as object is of type ast::LonDifuse
   */
  bool is_lon_difuse() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  LonDifuse *clone() const override { return new LonDifuse(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::LON_DIFUSE
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::LON_DIFUSE;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "LonDifuse"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "LonDifuse";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "LONGITUDINAL_DIFFUSION"
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override {
    return "LONGITUDINAL_DIFFUSION";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<LonDifuse>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const LonDifuse>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref LonDifuse.name
   */
  const std::shared_ptr<Name> &get_name() const noexcept { return name; }

  /**
   * \brief Getter for member variable \ref LonDifuse.expression
   */
  const std::shared_ptr<Expression> &get_expression() const noexcept {
    return expression;
  }

  /**
   * \brief Getter for member variable \ref LonDifuse.names
   */
  const NameVector &get_names() const noexcept { return names; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref LonDifuse.name (rvalue reference)
   */
  void set_name(std::shared_ptr<Name> &&name);

  /**
   * \brief Setter for member variable \ref LonDifuse.name
   */
  void set_name(const std::shared_ptr<Name> &name);

  /**
   * \brief Setter for member variable \ref LonDifuse.expression (rvalue
   * reference)
   */
  void set_expression(std::shared_ptr<Expression> &&expression);

  /**
   * \brief Setter for member variable \ref LonDifuse.expression
   */
  void set_expression(const std::shared_ptr<Expression> &expression);

  /**
   * \brief Setter for member variable \ref LonDifuse.names (rvalue reference)
   */
  void set_names(NameVector &&names);

  /**
   * \brief Setter for member variable \ref LonDifuse.names
   */
  void set_names(const NameVector &names);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_LON_DIFUSE_HPP
#ifndef NMODL_AST_REACTION_STATEMENT_HPP
#define NMODL_AST_REACTION_STATEMENT_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 *
 */
class ReactionStatement : public Statement {
private:
  /// TODO
  std::shared_ptr<Expression> reaction1;
  /// TODO
  ReactionOperator op;
  /// TODO
  std::shared_ptr<Expression> reaction2;
  /// TODO
  std::shared_ptr<Expression> expression1;
  /// TODO
  std::shared_ptr<Expression> expression2;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit ReactionStatement(Expression *reaction1, const ReactionOperator &op,
                             Expression *reaction2, Expression *expression1,
                             Expression *expression2);
  explicit ReactionStatement(const std::shared_ptr<Expression> &reaction1,
                             const ReactionOperator &op,
                             const std::shared_ptr<Expression> &reaction2,
                             const std::shared_ptr<Expression> &expression1,
                             const std::shared_ptr<Expression> &expression2);
  ReactionStatement(const ReactionStatement &obj);

  virtual ~ReactionStatement() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::ReactionStatement
   * \return true as object is of type ast::ReactionStatement
   */
  bool is_reaction_statement() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  ReactionStatement *clone() const override {
    return new ReactionStatement(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::REACTION_STATEMENT
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::REACTION_STATEMENT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "ReactionStatement"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "ReactionStatement";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "~ "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "~ "; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<ReactionStatement>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const ReactionStatement>(
        shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref ReactionStatement.reaction1
   */
  const std::shared_ptr<Expression> &get_reaction1() const noexcept {
    return reaction1;
  }

  /**
   * \brief Getter for member variable \ref ReactionStatement.op
   */
  const ReactionOperator &get_op() const noexcept { return op; }

  /**
   * \brief Getter for member variable \ref ReactionStatement.reaction2
   */
  const std::shared_ptr<Expression> &get_reaction2() const noexcept {
    return reaction2;
  }

  /**
   * \brief Getter for member variable \ref ReactionStatement.expression1
   */
  const std::shared_ptr<Expression> &get_expression1() const noexcept {
    return expression1;
  }

  /**
   * \brief Getter for member variable \ref ReactionStatement.expression2
   */
  const std::shared_ptr<Expression> &get_expression2() const noexcept {
    return expression2;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref ReactionStatement.reaction1 (rvalue
   * reference)
   */
  void set_reaction1(std::shared_ptr<Expression> &&reaction1);

  /**
   * \brief Setter for member variable \ref ReactionStatement.reaction1
   */
  void set_reaction1(const std::shared_ptr<Expression> &reaction1);

  /**
   * \brief Setter for member variable \ref ReactionStatement.op (rvalue
   * reference)
   */
  void set_op(ReactionOperator &&op);

  /**
   * \brief Setter for member variable \ref ReactionStatement.op
   */
  void set_op(const ReactionOperator &op);

  /**
   * \brief Setter for member variable \ref ReactionStatement.reaction2 (rvalue
   * reference)
   */
  void set_reaction2(std::shared_ptr<Expression> &&reaction2);

  /**
   * \brief Setter for member variable \ref ReactionStatement.reaction2
   */
  void set_reaction2(const std::shared_ptr<Expression> &reaction2);

  /**
   * \brief Setter for member variable \ref ReactionStatement.expression1
   * (rvalue reference)
   */
  void set_expression1(std::shared_ptr<Expression> &&expression1);

  /**
   * \brief Setter for member variable \ref ReactionStatement.expression1
   */
  void set_expression1(const std::shared_ptr<Expression> &expression1);

  /**
   * \brief Setter for member variable \ref ReactionStatement.expression2
   * (rvalue reference)
   */
  void set_expression2(std::shared_ptr<Expression> &&expression2);

  /**
   * \brief Setter for member variable \ref ReactionStatement.expression2
   */
  void set_expression2(const std::shared_ptr<Expression> &expression2);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_REACTION_STATEMENT_HPP
#ifndef NMODL_AST_LAG_STATEMENT_HPP
#define NMODL_AST_LAG_STATEMENT_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a LAG statement in the mod file
 *
 * An example of LAG statement usage:
 *
 * \code{.mod}
 *     PROCEDURE lates() {
 *         LAG ina BY tau
 *         neo = lag_ina_tau
 *         if (ena < 70) {ena = 70}
 *     }
 * \endcode
 *
 */
class LagStatement : public Statement {
private:
  /// Name of the variable (TODO)
  std::shared_ptr<Identifier> name;
  /// Name of the variable (TODO)
  std::shared_ptr<Name> byname;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit LagStatement(Identifier *name, Name *byname);
  explicit LagStatement(const std::shared_ptr<Identifier> &name,
                        const std::shared_ptr<Name> &byname);
  LagStatement(const LagStatement &obj);

  virtual ~LagStatement() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::LagStatement
   * \return true as object is of type ast::LagStatement
   */
  bool is_lag_statement() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  LagStatement *clone() const override { return new LagStatement(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::LAG_STATEMENT
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::LAG_STATEMENT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "LagStatement"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "LagStatement";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "LAG "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "LAG "; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<LagStatement>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const LagStatement>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref LagStatement.name
   */
  const std::shared_ptr<Identifier> &get_name() const noexcept { return name; }

  /**
   * \brief Getter for member variable \ref LagStatement.byname
   */
  const std::shared_ptr<Name> &get_byname() const noexcept { return byname; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref LagStatement.name (rvalue reference)
   */
  void set_name(std::shared_ptr<Identifier> &&name);

  /**
   * \brief Setter for member variable \ref LagStatement.name
   */
  void set_name(const std::shared_ptr<Identifier> &name);

  /**
   * \brief Setter for member variable \ref LagStatement.byname (rvalue
   * reference)
   */
  void set_byname(std::shared_ptr<Name> &&byname);

  /**
   * \brief Setter for member variable \ref LagStatement.byname
   */
  void set_byname(const std::shared_ptr<Name> &byname);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_LAG_STATEMENT_HPP
#ifndef NMODL_AST_QUEUE_STATEMENT_HPP
#define NMODL_AST_QUEUE_STATEMENT_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represent queue statement in NMODL
 *
 *
 */
class QueueStatement : public Statement {
private:
  /// queue type (put/get)
  std::shared_ptr<QueueExpressionType> qtype;
  /// Name of the variable
  std::shared_ptr<Identifier> name;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit QueueStatement(QueueExpressionType *qtype, Identifier *name);
  explicit QueueStatement(const std::shared_ptr<QueueExpressionType> &qtype,
                          const std::shared_ptr<Identifier> &name);
  QueueStatement(const QueueStatement &obj);

  virtual ~QueueStatement() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::QueueStatement
   * \return true as object is of type ast::QueueStatement
   */
  bool is_queue_statement() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  QueueStatement *clone() const override { return new QueueStatement(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::QUEUE_STATEMENT
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::QUEUE_STATEMENT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "QueueStatement"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "QueueStatement";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<QueueStatement>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const QueueStatement>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref QueueStatement.qtype
   */
  const std::shared_ptr<QueueExpressionType> &get_qtype() const noexcept {
    return qtype;
  }

  /**
   * \brief Getter for member variable \ref QueueStatement.name
   */
  const std::shared_ptr<Identifier> &get_name() const noexcept { return name; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref QueueStatement.qtype (rvalue
   * reference)
   */
  void set_qtype(std::shared_ptr<QueueExpressionType> &&qtype);

  /**
   * \brief Setter for member variable \ref QueueStatement.qtype
   */
  void set_qtype(const std::shared_ptr<QueueExpressionType> &qtype);

  /**
   * \brief Setter for member variable \ref QueueStatement.name (rvalue
   * reference)
   */
  void set_name(std::shared_ptr<Identifier> &&name);

  /**
   * \brief Setter for member variable \ref QueueStatement.name
   */
  void set_name(const std::shared_ptr<Identifier> &name);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_QUEUE_STATEMENT_HPP
#ifndef NMODL_AST_CONSTANT_STATEMENT_HPP
#define NMODL_AST_CONSTANT_STATEMENT_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represent statement in CONSTANT block of NMODL
 *
 * \todo As ConstantStatement wraps a single ConstantVar,
 *       this or ast::ConstantVar can be redundant in the future.
 *
 */
class ConstantStatement : public Statement {
private:
  /// single constant variable
  std::shared_ptr<ConstantVar> constant;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit ConstantStatement(ConstantVar *constant);
  explicit ConstantStatement(const std::shared_ptr<ConstantVar> &constant);
  ConstantStatement(const ConstantStatement &obj);

  virtual ~ConstantStatement() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::ConstantStatement
   * \return true as object is of type ast::ConstantStatement
   */
  bool is_constant_statement() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  ConstantStatement *clone() const override {
    return new ConstantStatement(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::CONSTANT_STATEMENT
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::CONSTANT_STATEMENT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "ConstantStatement"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "ConstantStatement";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<ConstantStatement>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const ConstantStatement>(
        shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref ConstantStatement.constant
   */
  const std::shared_ptr<ConstantVar> &get_constant() const noexcept {
    return constant;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref ConstantStatement.constant (rvalue
   * reference)
   */
  void set_constant(std::shared_ptr<ConstantVar> &&constant);

  /**
   * \brief Setter for member variable \ref ConstantStatement.constant
   */
  void set_constant(const std::shared_ptr<ConstantVar> &constant);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_CONSTANT_STATEMENT_HPP
#ifndef NMODL_AST_TABLE_STATEMENT_HPP
#define NMODL_AST_TABLE_STATEMENT_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents TABLE statement in NMODL
 *
 *
 */
class TableStatement : public Statement {
private:
  /// Variables in the table
  NameVector table_vars;
  /// dependent variables
  NameVector depend_vars;
  /// from value
  std::shared_ptr<Expression> from;
  /// to values
  std::shared_ptr<Expression> to;
  /// an increment factor
  std::shared_ptr<Integer> with;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit TableStatement(NameVector table_vars, NameVector depend_vars,
                          Expression *from, Expression *to, Integer *with);
  explicit TableStatement(const NameVector &table_vars,
                          const NameVector &depend_vars,
                          const std::shared_ptr<Expression> &from,
                          const std::shared_ptr<Expression> &to,
                          const std::shared_ptr<Integer> &with);
  TableStatement(const TableStatement &obj);

  virtual ~TableStatement() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::TableStatement
   * \return true as object is of type ast::TableStatement
   */
  bool is_table_statement() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  TableStatement *clone() const override { return new TableStatement(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::TABLE_STATEMENT
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::TABLE_STATEMENT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "TableStatement"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "TableStatement";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "TABLE "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "TABLE "; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<TableStatement>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const TableStatement>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref TableStatement.table_vars
   */
  const NameVector &get_table_vars() const noexcept { return table_vars; }

  /**
   * \brief Getter for member variable \ref TableStatement.depend_vars
   */
  const NameVector &get_depend_vars() const noexcept { return depend_vars; }

  /**
   * \brief Getter for member variable \ref TableStatement.from
   */
  const std::shared_ptr<Expression> &get_from() const noexcept { return from; }

  /**
   * \brief Getter for member variable \ref TableStatement.to
   */
  const std::shared_ptr<Expression> &get_to() const noexcept { return to; }

  /**
   * \brief Getter for member variable \ref TableStatement.with
   */
  const std::shared_ptr<Integer> &get_with() const noexcept { return with; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref TableStatement.table_vars (rvalue
   * reference)
   */
  void set_table_vars(NameVector &&table_vars);

  /**
   * \brief Setter for member variable \ref TableStatement.table_vars
   */
  void set_table_vars(const NameVector &table_vars);

  /**
   * \brief Setter for member variable \ref TableStatement.depend_vars (rvalue
   * reference)
   */
  void set_depend_vars(NameVector &&depend_vars);

  /**
   * \brief Setter for member variable \ref TableStatement.depend_vars
   */
  void set_depend_vars(const NameVector &depend_vars);

  /**
   * \brief Setter for member variable \ref TableStatement.from (rvalue
   * reference)
   */
  void set_from(std::shared_ptr<Expression> &&from);

  /**
   * \brief Setter for member variable \ref TableStatement.from
   */
  void set_from(const std::shared_ptr<Expression> &from);

  /**
   * \brief Setter for member variable \ref TableStatement.to (rvalue reference)
   */
  void set_to(std::shared_ptr<Expression> &&to);

  /**
   * \brief Setter for member variable \ref TableStatement.to
   */
  void set_to(const std::shared_ptr<Expression> &to);

  /**
   * \brief Setter for member variable \ref TableStatement.with (rvalue
   * reference)
   */
  void set_with(std::shared_ptr<Integer> &&with);

  /**
   * \brief Setter for member variable \ref TableStatement.with
   */
  void set_with(const std::shared_ptr<Integer> &with);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_TABLE_STATEMENT_HPP
#ifndef NMODL_AST_SUFFIX_HPP
#define NMODL_AST_SUFFIX_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents SUFFIX statement in NMODL
 *
 *
 */
class Suffix : public Statement {
private:
  /// type of channel
  std::shared_ptr<Name> type;
  /// Name of the channel
  std::shared_ptr<Name> name;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit Suffix(Name *type, Name *name);
  explicit Suffix(const std::shared_ptr<Name> &type,
                  const std::shared_ptr<Name> &name);
  Suffix(const Suffix &obj);

  virtual ~Suffix() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::Suffix
   * \return true as object is of type ast::Suffix
   */
  bool is_suffix() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  Suffix *clone() const override { return new Suffix(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::SUFFIX
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::SUFFIX;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Suffix"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override { return "Suffix"; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Suffix>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Suffix>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref Suffix.type
   */
  const std::shared_ptr<Name> &get_type() const noexcept { return type; }

  /**
   * \brief Return name of the node
   *
   * Some ast nodes have a member marked designated as node name. For example,
   * in case of this ast::Name has name designated as a
   * node name.
   *
   * @return name of the node as std::string
   *
   * \sa Ast::get_node_type_name
   */
  std::string get_node_name() const override;

  /**
   * \brief Getter for member variable \ref Suffix.name
   */
  const std::shared_ptr<Name> &get_name() const noexcept { return name; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref Suffix.type (rvalue reference)
   */
  void set_type(std::shared_ptr<Name> &&type);

  /**
   * \brief Setter for member variable \ref Suffix.type
   */
  void set_type(const std::shared_ptr<Name> &type);

  /**
   * \brief Setter for member variable \ref Suffix.name (rvalue reference)
   */
  void set_name(std::shared_ptr<Name> &&name);

  /**
   * \brief Setter for member variable \ref Suffix.name
   */
  void set_name(const std::shared_ptr<Name> &name);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_SUFFIX_HPP
#ifndef NMODL_AST_USEION_HPP
#define NMODL_AST_USEION_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents USEION statement in NMODL
 *
 *
 */
class Useion : public Statement {
private:
  /// Name of ion
  std::shared_ptr<Name> name;
  /// Variables being read
  ReadIonVarVector readlist;
  /// Variables being written
  WriteIonVarVector writelist;
  /// (TODO)
  std::shared_ptr<Valence> valence;
  /// Ontology to indicate the chemical ion
  std::shared_ptr<String> ontology_id;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit Useion(Name *name, ReadIonVarVector readlist,
                  WriteIonVarVector writelist, Valence *valence,
                  String *ontology_id);
  explicit Useion(const std::shared_ptr<Name> &name,
                  const ReadIonVarVector &readlist,
                  const WriteIonVarVector &writelist,
                  const std::shared_ptr<Valence> &valence,
                  const std::shared_ptr<String> &ontology_id);
  Useion(const Useion &obj);

  virtual ~Useion() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::Useion
   * \return true as object is of type ast::Useion
   */
  bool is_useion() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  Useion *clone() const override { return new Useion(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::USEION
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::USEION;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Useion"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override { return "Useion"; }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "USEION "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "USEION "; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Useion>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Useion>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return name of the node
   *
   * Some ast nodes have a member marked designated as node name. For example,
   * in case of this ast::Name has name designated as a
   * node name.
   *
   * @return name of the node as std::string
   *
   * \sa Ast::get_node_type_name
   */
  std::string get_node_name() const override;

  /**
   * \brief Getter for member variable \ref Useion.name
   */
  const std::shared_ptr<Name> &get_name() const noexcept { return name; }

  /**
   * \brief Getter for member variable \ref Useion.readlist
   */
  const ReadIonVarVector &get_readlist() const noexcept { return readlist; }

  /**
   * \brief Getter for member variable \ref Useion.writelist
   */
  const WriteIonVarVector &get_writelist() const noexcept { return writelist; }

  /**
   * \brief Getter for member variable \ref Useion.valence
   */
  const std::shared_ptr<Valence> &get_valence() const noexcept {
    return valence;
  }

  /**
   * \brief Getter for member variable \ref Useion.ontology_id
   */
  const std::shared_ptr<String> &get_ontology_id() const noexcept {
    return ontology_id;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref Useion.name (rvalue reference)
   */
  void set_name(std::shared_ptr<Name> &&name);

  /**
   * \brief Setter for member variable \ref Useion.name
   */
  void set_name(const std::shared_ptr<Name> &name);

  /**
   * \brief Setter for member variable \ref Useion.readlist (rvalue reference)
   */
  void set_readlist(ReadIonVarVector &&readlist);

  /**
   * \brief Setter for member variable \ref Useion.readlist
   */
  void set_readlist(const ReadIonVarVector &readlist);

  /**
   * \brief Setter for member variable \ref Useion.writelist (rvalue reference)
   */
  void set_writelist(WriteIonVarVector &&writelist);

  /**
   * \brief Setter for member variable \ref Useion.writelist
   */
  void set_writelist(const WriteIonVarVector &writelist);

  /**
   * \brief Setter for member variable \ref Useion.valence (rvalue reference)
   */
  void set_valence(std::shared_ptr<Valence> &&valence);

  /**
   * \brief Setter for member variable \ref Useion.valence
   */
  void set_valence(const std::shared_ptr<Valence> &valence);

  /**
   * \brief Setter for member variable \ref Useion.ontology_id (rvalue
   * reference)
   */
  void set_ontology_id(std::shared_ptr<String> &&ontology_id);

  /**
   * \brief Setter for member variable \ref Useion.ontology_id
   */
  void set_ontology_id(const std::shared_ptr<String> &ontology_id);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_USEION_HPP
#ifndef NMODL_AST_NONSPECIFIC_HPP
#define NMODL_AST_NONSPECIFIC_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents NONSPECIFIC_CURRENT variables statement in NMODL
 *
 *
 */
class Nonspecific : public Statement {
private:
  /// Vector of non specific variables
  NonspecificCurVarVector currents;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit Nonspecific(NonspecificCurVarVector currents);
  Nonspecific(const Nonspecific &obj);

  virtual ~Nonspecific() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::Nonspecific
   * \return true as object is of type ast::Nonspecific
   */
  bool is_nonspecific() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  Nonspecific *clone() const override { return new Nonspecific(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::NONSPECIFIC
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::NONSPECIFIC;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Nonspecific"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "Nonspecific";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "NONSPECIFIC_CURRENT "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override {
    return "NONSPECIFIC_CURRENT ";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Nonspecific>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Nonspecific>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref Nonspecific.currents
   */
  const NonspecificCurVarVector &get_currents() const noexcept {
    return currents;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref Nonspecific.currents (rvalue
   * reference)
   */
  void set_currents(NonspecificCurVarVector &&currents);

  /**
   * \brief Setter for member variable \ref Nonspecific.currents
   */
  void set_currents(const NonspecificCurVarVector &currents);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_NONSPECIFIC_HPP
#ifndef NMODL_AST_ELCTRODE_CURRENT_HPP
#define NMODL_AST_ELCTRODE_CURRENT_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents ELECTRODE_CURRENT variables statement in NMODL
 *
 *
 */
class ElctrodeCurrent : public Statement {
private:
  /// Vector of electrode current variables
  ElectrodeCurVarVector currents;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit ElctrodeCurrent(ElectrodeCurVarVector currents);
  ElctrodeCurrent(const ElctrodeCurrent &obj);

  virtual ~ElctrodeCurrent() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::ElctrodeCurrent
   * \return true as object is of type ast::ElctrodeCurrent
   */
  bool is_elctrode_current() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  ElctrodeCurrent *clone() const override { return new ElctrodeCurrent(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::ELCTRODE_CURRENT
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::ELCTRODE_CURRENT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "ElctrodeCurrent"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "ElctrodeCurrent";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "ELECTRODE_CURRENT "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override {
    return "ELECTRODE_CURRENT ";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<ElctrodeCurrent>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const ElctrodeCurrent>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref ElctrodeCurrent.currents
   */
  const ElectrodeCurVarVector &get_currents() const noexcept {
    return currents;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref ElctrodeCurrent.currents (rvalue
   * reference)
   */
  void set_currents(ElectrodeCurVarVector &&currents);

  /**
   * \brief Setter for member variable \ref ElctrodeCurrent.currents
   */
  void set_currents(const ElectrodeCurVarVector &currents);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_ELCTRODE_CURRENT_HPP
#ifndef NMODL_AST_SECTION_HPP
#define NMODL_AST_SECTION_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents SECTION variables statement in NMODL
 *
 *
 */
class Section : public Statement {
private:
  /// Vector of section variables
  SectionVarVector sections;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit Section(SectionVarVector sections);
  Section(const Section &obj);

  virtual ~Section() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::Section
   * \return true as object is of type ast::Section
   */
  bool is_section() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  Section *clone() const override { return new Section(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::SECTION
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::SECTION;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Section"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override { return "Section"; }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "SECTION "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "SECTION "; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Section>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Section>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref Section.sections
   */
  const SectionVarVector &get_sections() const noexcept { return sections; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref Section.sections (rvalue reference)
   */
  void set_sections(SectionVarVector &&sections);

  /**
   * \brief Setter for member variable \ref Section.sections
   */
  void set_sections(const SectionVarVector &sections);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_SECTION_HPP
#ifndef NMODL_AST_RANGE_HPP
#define NMODL_AST_RANGE_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents RANGE variables statement in NMODL
 *
 *
 */
class Range : public Statement {
private:
  /// Vector of range variables
  RangeVarVector variables;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit Range(RangeVarVector variables);
  Range(const Range &obj);

  virtual ~Range() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::Range
   * \return true as object is of type ast::Range
   */
  bool is_range() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  Range *clone() const override { return new Range(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::RANGE
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::RANGE;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Range"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override { return "Range"; }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "RANGE "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "RANGE "; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Range>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Range>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref Range.variables
   */
  const RangeVarVector &get_variables() const noexcept { return variables; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref Range.variables (rvalue reference)
   */
  void set_variables(RangeVarVector &&variables);

  /**
   * \brief Setter for member variable \ref Range.variables
   */
  void set_variables(const RangeVarVector &variables);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_RANGE_HPP
#ifndef NMODL_AST_GLOBAL_HPP
#define NMODL_AST_GLOBAL_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents GLOBAL statement in NMODL
 *
 *
 */
class Global : public Statement {
private:
  /// Vector of global variables
  GlobalVarVector variables;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit Global(GlobalVarVector variables);
  Global(const Global &obj);

  virtual ~Global() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::Global
   * \return true as object is of type ast::Global
   */
  bool is_global() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  Global *clone() const override { return new Global(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::GLOBAL
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::GLOBAL;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Global"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override { return "Global"; }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "GLOBAL "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "GLOBAL "; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Global>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Global>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Add member to variables by raw pointer
   */
  void emplace_back_global_var(GlobalVar *n) {
    variables.emplace_back(n);

    // set parents
    n->set_parent(this);
  }

  /**
   * \brief Add member to variables by shared_ptr
   */
  void emplace_back_global_var(std::shared_ptr<GlobalVar> n) {
    variables.emplace_back(n);
    // set parents
    n->set_parent(this);
  }

  /**
   * \brief Erase member to variables
   */
  GlobalVarVector::const_iterator
  erase_global_var(GlobalVarVector::const_iterator first) {
    auto first_it = const_iter_cast(variables, first);
    return variables.erase(first_it);
  }
  /**
   * \brief Erase members to variables
   */
  GlobalVarVector::const_iterator
  erase_global_var(GlobalVarVector::const_iterator first,
                   GlobalVarVector::const_iterator last) {
    auto first_it = const_iter_cast(variables, first);
    auto last_it = const_iter_cast(variables, last);
    return variables.erase(first_it, last_it);
  }
  /**
   * \brief Erase non-consecutive members to variables
   *
   * loosely following the cpp reference of remove_if
   */
  size_t erase_global_var(std::unordered_set<GlobalVar *> &to_be_erased) {
    auto first = variables.begin();
    auto last = variables.end();
    auto result = first;

    while (first != last) {
      // automatically erase dangling pointers from the uset while
      // looking for them to erase them in the vector
      if (to_be_erased.erase(first->get()) == 0) {
        reset_global_var(result, *first);
        ++result;
      }
      ++first;
    }

    size_t out = last - result;
    erase_global_var(result, last);

    return out;
  }

  /**
   * \brief Insert member to variables
   */
  GlobalVarVector::const_iterator
  insert_global_var(GlobalVarVector::const_iterator position,
                    const std::shared_ptr<GlobalVar> &n) {
    n->set_parent(this);
    auto pos_it = const_iter_cast(variables, position);
    return variables.insert(pos_it, n);
  }
  /**
   * \brief Insert members to variables
   */
  template <class NodeType, class InputIterator>
  void insert_global_var(GlobalVarVector::const_iterator position, NodeType &to,
                         InputIterator first, InputIterator last) {

    for (auto it = first; it != last; ++it) {
      auto &n = *it;
      // set parents
      n->set_parent(this);
    }
    auto pos_it = const_iter_cast(variables, position);
    auto first_it = const_iter_cast(to, first);
    auto last_it = const_iter_cast(to, last);
    variables.insert(pos_it, first_it, last_it);
  }

  /**
   * \brief Reset member to variables
   */
  void reset_global_var(GlobalVarVector::const_iterator position,
                        GlobalVar *n) {
    // set parents
    n->set_parent(this);

    variables[position - variables.begin()].reset(n);
  }

  /**
   * \brief Reset member to variables
   */
  void reset_global_var(GlobalVarVector::const_iterator position,
                        std::shared_ptr<GlobalVar> n) {
    // set parents
    n->set_parent(this);

    variables[position - variables.begin()] = n;
  }

  /**
   * \brief Getter for member variable \ref Global.variables
   */
  const GlobalVarVector &get_variables() const noexcept { return variables; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref Global.variables (rvalue reference)
   */
  void set_variables(GlobalVarVector &&variables);

  /**
   * \brief Setter for member variable \ref Global.variables
   */
  void set_variables(const GlobalVarVector &variables);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_GLOBAL_HPP
#ifndef NMODL_AST_POINTER_HPP
#define NMODL_AST_POINTER_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents POINTER statement in NMODL
 *
 *
 */
class Pointer : public Statement {
private:
  /// Vector of pointer variables
  PointerVarVector variables;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit Pointer(PointerVarVector variables);
  Pointer(const Pointer &obj);

  virtual ~Pointer() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::Pointer
   * \return true as object is of type ast::Pointer
   */
  bool is_pointer() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  Pointer *clone() const override { return new Pointer(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::POINTER
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::POINTER;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Pointer"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override { return "Pointer"; }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "POINTER "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "POINTER "; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Pointer>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Pointer>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref Pointer.variables
   */
  const PointerVarVector &get_variables() const noexcept { return variables; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref Pointer.variables (rvalue reference)
   */
  void set_variables(PointerVarVector &&variables);

  /**
   * \brief Setter for member variable \ref Pointer.variables
   */
  void set_variables(const PointerVarVector &variables);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_POINTER_HPP
#ifndef NMODL_AST_BBCORE_POINTER_HPP
#define NMODL_AST_BBCORE_POINTER_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents BBCOREPOINTER statement in NMODL
 *
 * Here is an example of BBCOREPOINTER statement:
 *
 * \code{.mod}
 *       NEURON {
 *           THREADSAFE
 *           POINT_PROCESS ProbAMPANMDA_EMS
 *           BBCOREPOINTER rng, data
 * \endcode
 *
 */
class BbcorePointer : public Statement {
private:
  /// Vector of bbcore pointer variables
  BbcorePointerVarVector variables;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit BbcorePointer(BbcorePointerVarVector variables);
  BbcorePointer(const BbcorePointer &obj);

  virtual ~BbcorePointer() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::BbcorePointer
   * \return true as object is of type ast::BbcorePointer
   */
  bool is_bbcore_pointer() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  BbcorePointer *clone() const override { return new BbcorePointer(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::BBCORE_POINTER
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::BBCORE_POINTER;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "BbcorePointer"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "BbcorePointer";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "BBCOREPOINTER "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override {
    return "BBCOREPOINTER ";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<BbcorePointer>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const BbcorePointer>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref BbcorePointer.variables
   */
  const BbcorePointerVarVector &get_variables() const noexcept {
    return variables;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref BbcorePointer.variables (rvalue
   * reference)
   */
  void set_variables(BbcorePointerVarVector &&variables);

  /**
   * \brief Setter for member variable \ref BbcorePointer.variables
   */
  void set_variables(const BbcorePointerVarVector &variables);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_BBCORE_POINTER_HPP
#ifndef NMODL_AST_EXTERNAL_HPP
#define NMODL_AST_EXTERNAL_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents EXTERNAL statement in NMODL
 *
 *
 */
class External : public Statement {
private:
  /// Vector of external variables
  ExternVarVector variables;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit External(ExternVarVector variables);
  External(const External &obj);

  virtual ~External() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::External
   * \return true as object is of type ast::External
   */
  bool is_external() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  External *clone() const override { return new External(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::EXTERNAL
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::EXTERNAL;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "External"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "External";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "EXTERNAL "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "EXTERNAL "; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<External>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const External>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref External.variables
   */
  const ExternVarVector &get_variables() const noexcept { return variables; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref External.variables (rvalue
   * reference)
   */
  void set_variables(ExternVarVector &&variables);

  /**
   * \brief Setter for member variable \ref External.variables
   */
  void set_variables(const ExternVarVector &variables);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_EXTERNAL_HPP
#ifndef NMODL_AST_THREAD_SAFE_HPP
#define NMODL_AST_THREAD_SAFE_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents THREADSAFE statement in NMODL
 *
 *
 */
class ThreadSafe : public Statement {
private:
  /// Vector of thread safe variables
  ThreadsafeVarVector variables;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit ThreadSafe(ThreadsafeVarVector variables);
  ThreadSafe(const ThreadSafe &obj);

  virtual ~ThreadSafe() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::ThreadSafe
   * \return true as object is of type ast::ThreadSafe
   */
  bool is_thread_safe() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  ThreadSafe *clone() const override { return new ThreadSafe(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::THREAD_SAFE
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::THREAD_SAFE;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "ThreadSafe"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "ThreadSafe";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "THREADSAFE"
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "THREADSAFE"; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<ThreadSafe>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const ThreadSafe>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref ThreadSafe.variables
   */
  const ThreadsafeVarVector &get_variables() const noexcept {
    return variables;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref ThreadSafe.variables (rvalue
   * reference)
   */
  void set_variables(ThreadsafeVarVector &&variables);

  /**
   * \brief Setter for member variable \ref ThreadSafe.variables
   */
  void set_variables(const ThreadsafeVarVector &variables);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_THREAD_SAFE_HPP
#ifndef NMODL_AST_VERBATIM_HPP
#define NMODL_AST_VERBATIM_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a C code block
 *
 *
 */
class Verbatim : public Statement {
private:
  /// C code as a string
  std::shared_ptr<String> statement;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit Verbatim(String *statement);
  explicit Verbatim(const std::shared_ptr<String> &statement);
  Verbatim(const Verbatim &obj);

  virtual ~Verbatim() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::Verbatim
   * \return true as object is of type ast::Verbatim
   */
  bool is_verbatim() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  Verbatim *clone() const override { return new Verbatim(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::VERBATIM
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::VERBATIM;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Verbatim"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "Verbatim";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "VERBATIM"
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "VERBATIM"; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Verbatim>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Verbatim>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref Verbatim.statement
   */
  const std::shared_ptr<String> &get_statement() const noexcept {
    return statement;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref Verbatim.statement (rvalue
   * reference)
   */
  void set_statement(std::shared_ptr<String> &&statement);

  /**
   * \brief Setter for member variable \ref Verbatim.statement
   */
  void set_statement(const std::shared_ptr<String> &statement);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_VERBATIM_HPP
#ifndef NMODL_AST_LINE_COMMENT_HPP
#define NMODL_AST_LINE_COMMENT_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a one line comment in NMODL
 *
 *
 */
class LineComment : public Statement {
private:
  /// comment text
  std::shared_ptr<String> statement;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit LineComment(String *statement);
  explicit LineComment(const std::shared_ptr<String> &statement);
  LineComment(const LineComment &obj);

  virtual ~LineComment() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::LineComment
   * \return true as object is of type ast::LineComment
   */
  bool is_line_comment() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  LineComment *clone() const override { return new LineComment(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::LINE_COMMENT
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::LINE_COMMENT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "LineComment"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "LineComment";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<LineComment>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const LineComment>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref LineComment.statement
   */
  const std::shared_ptr<String> &get_statement() const noexcept {
    return statement;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref LineComment.statement (rvalue
   * reference)
   */
  void set_statement(std::shared_ptr<String> &&statement);

  /**
   * \brief Setter for member variable \ref LineComment.statement
   */
  void set_statement(const std::shared_ptr<String> &statement);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_LINE_COMMENT_HPP
#ifndef NMODL_AST_BLOCK_COMMENT_HPP
#define NMODL_AST_BLOCK_COMMENT_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a multi-line comment in NMODL
 *
 *
 */
class BlockComment : public Statement {
private:
  /// comment text
  std::shared_ptr<String> statement;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit BlockComment(String *statement);
  explicit BlockComment(const std::shared_ptr<String> &statement);
  BlockComment(const BlockComment &obj);

  virtual ~BlockComment() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::BlockComment
   * \return true as object is of type ast::BlockComment
   */
  bool is_block_comment() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  BlockComment *clone() const override { return new BlockComment(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::BLOCK_COMMENT
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::BLOCK_COMMENT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "BlockComment"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "BlockComment";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "COMMENT"
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "COMMENT"; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<BlockComment>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const BlockComment>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref BlockComment.statement
   */
  const std::shared_ptr<String> &get_statement() const noexcept {
    return statement;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref BlockComment.statement (rvalue
   * reference)
   */
  void set_statement(std::shared_ptr<String> &&statement);

  /**
   * \brief Setter for member variable \ref BlockComment.statement
   */
  void set_statement(const std::shared_ptr<String> &statement);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_BLOCK_COMMENT_HPP
#ifndef NMODL_AST_ONTOLOGY_STATEMENT_HPP
#define NMODL_AST_ONTOLOGY_STATEMENT_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents CURIE information in NMODL
 *
 *
 */
class OntologyStatement : public Statement {
private:
  /// Ontology name
  std::shared_ptr<String> ontology_id;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit OntologyStatement(String *ontology_id);
  explicit OntologyStatement(const std::shared_ptr<String> &ontology_id);
  OntologyStatement(const OntologyStatement &obj);

  virtual ~OntologyStatement() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::OntologyStatement
   * \return true as object is of type ast::OntologyStatement
   */
  bool is_ontology_statement() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  OntologyStatement *clone() const override {
    return new OntologyStatement(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::ONTOLOGY_STATEMENT
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::ONTOLOGY_STATEMENT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "OntologyStatement"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "OntologyStatement";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "REPRESENTS "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "REPRESENTS "; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<OntologyStatement>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const OntologyStatement>(
        shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref OntologyStatement.ontology_id
   */
  const std::shared_ptr<String> &get_ontology_id() const noexcept {
    return ontology_id;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref OntologyStatement.ontology_id
   * (rvalue reference)
   */
  void set_ontology_id(std::shared_ptr<String> &&ontology_id);

  /**
   * \brief Setter for member variable \ref OntologyStatement.ontology_id
   */
  void set_ontology_id(const std::shared_ptr<String> &ontology_id);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_ONTOLOGY_STATEMENT_HPP
#ifndef NMODL_AST_PROGRAM_HPP
#define NMODL_AST_PROGRAM_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents top level AST node for whole NMODL input
 *
 *
 */
class Program : public Ast {
private:
  /// Vector of top level blocks in the mod file
  NodeVector blocks;
  /// token with location information
  std::shared_ptr<ModToken> token;
  /// symbol table for a block
  symtab::SymbolTable *symtab = nullptr;
  /// global symbol table for model
  symtab::ModelSymbolTable model_symtab;

public:
  /// \name Ctor & dtor
  /// \{

  explicit Program(NodeVector blocks);
  Program(const Program &obj);

  Program() = default;

  virtual ~Program() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::Program
   * \return true as object is of type ast::Program
   */
  bool is_program() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  Program *clone() const override { return new Program(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::PROGRAM
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::PROGRAM;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Program"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override { return "Program"; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Program>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Program>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return associated symbol table for the current ast node
   *
   * Only certain ast nodes (e.g. inherited from ast::Block) have associated
   * symbol table. These nodes have nmodl::symtab::SymbolTable as member
   * and it can be accessed using this method.
   *
   * \return pointer to the symbol table
   *
   * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
   */
  symtab::SymbolTable *get_symbol_table() const override { return symtab; }

  /**
   * \brief Return global symbol table for the mod file
   */
  symtab::ModelSymbolTable *get_model_symbol_table() { return &model_symtab; }

  /**
   * \brief Add member to blocks by raw pointer
   */
  void emplace_back_node(Node *n) {
    blocks.emplace_back(n);

    // set parents
    n->set_parent(this);
  }

  /**
   * \brief Add member to blocks by shared_ptr
   */
  void emplace_back_node(std::shared_ptr<Node> n) {
    blocks.emplace_back(n);
    // set parents
    n->set_parent(this);
  }

  /**
   * \brief Erase member to blocks
   */
  NodeVector::const_iterator erase_node(NodeVector::const_iterator first) {
    auto first_it = const_iter_cast(blocks, first);
    return blocks.erase(first_it);
  }
  /**
   * \brief Erase members to blocks
   */
  NodeVector::const_iterator erase_node(NodeVector::const_iterator first,
                                        NodeVector::const_iterator last) {
    auto first_it = const_iter_cast(blocks, first);
    auto last_it = const_iter_cast(blocks, last);
    return blocks.erase(first_it, last_it);
  }
  /**
   * \brief Erase non-consecutive members to blocks
   *
   * loosely following the cpp reference of remove_if
   */
  size_t erase_node(std::unordered_set<Node *> &to_be_erased) {
    auto first = blocks.begin();
    auto last = blocks.end();
    auto result = first;

    while (first != last) {
      // automatically erase dangling pointers from the uset while
      // looking for them to erase them in the vector
      if (to_be_erased.erase(first->get()) == 0) {
        reset_node(result, *first);
        ++result;
      }
      ++first;
    }

    size_t out = last - result;
    erase_node(result, last);

    return out;
  }

  /**
   * \brief Insert member to blocks
   */
  NodeVector::const_iterator insert_node(NodeVector::const_iterator position,
                                         const std::shared_ptr<Node> &n) {
    n->set_parent(this);
    auto pos_it = const_iter_cast(blocks, position);
    return blocks.insert(pos_it, n);
  }
  /**
   * \brief Insert members to blocks
   */
  template <class NodeType, class InputIterator>
  void insert_node(NodeVector::const_iterator position, NodeType &to,
                   InputIterator first, InputIterator last) {

    for (auto it = first; it != last; ++it) {
      auto &n = *it;
      // set parents
      n->set_parent(this);
    }
    auto pos_it = const_iter_cast(blocks, position);
    auto first_it = const_iter_cast(to, first);
    auto last_it = const_iter_cast(to, last);
    blocks.insert(pos_it, first_it, last_it);
  }

  /**
   * \brief Reset member to blocks
   */
  void reset_node(NodeVector::const_iterator position, Node *n) {
    // set parents
    n->set_parent(this);

    blocks[position - blocks.begin()].reset(n);
  }

  /**
   * \brief Reset member to blocks
   */
  void reset_node(NodeVector::const_iterator position,
                  std::shared_ptr<Node> n) {
    // set parents
    n->set_parent(this);

    blocks[position - blocks.begin()] = n;
  }

  /**
   * \brief Getter for member variable \ref Program.blocks
   */
  const NodeVector &get_blocks() const noexcept { return blocks; }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Set symbol table for the current ast node
   *
   * Top level, block scoped nodes store symbol table in the ast node.
   * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
   * for every node in the ast.
   *
   * \sa nmodl::visitor::SymtabVisitor
   */
  void set_symbol_table(symtab::SymbolTable *newsymtab) override {
    symtab = newsymtab;
  }

  /**
   * \brief Setter for member variable \ref Program.blocks (rvalue reference)
   */
  void set_blocks(NodeVector &&blocks);

  /**
   * \brief Setter for member variable \ref Program.blocks
   */
  void set_blocks(const NodeVector &blocks);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_PROGRAM_HPP
#ifndef NMODL_AST_NRN_STATE_BLOCK_HPP
#define NMODL_AST_NRN_STATE_BLOCK_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents the coreneuron nrn_state callback function
 *
 *
 */
class NrnStateBlock : public Block {
private:
  /// solve blocks to be called or generated
  StatementVector solve_statements;
  /// token with location information
  std::shared_ptr<ModToken> token;
  /// symbol table for a block
  symtab::SymbolTable *symtab = nullptr;

public:
  /// \name Ctor & dtor
  /// \{

  explicit NrnStateBlock(StatementVector solve_statements);
  NrnStateBlock(const NrnStateBlock &obj);

  virtual ~NrnStateBlock() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::NrnStateBlock
   * \return true as object is of type ast::NrnStateBlock
   */
  bool is_nrn_state_block() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  NrnStateBlock *clone() const override { return new NrnStateBlock(*this); }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::NRN_STATE_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::NRN_STATE_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "NrnStateBlock"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "NrnStateBlock";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "NRN_STATE "
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override { return "NRN_STATE "; }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<NrnStateBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const NrnStateBlock>(shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return associated symbol table for the current ast node
   *
   * Only certain ast nodes (e.g. inherited from ast::Block) have associated
   * symbol table. These nodes have nmodl::symtab::SymbolTable as member
   * and it can be accessed using this method.
   *
   * \return pointer to the symbol table
   *
   * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
   */
  symtab::SymbolTable *get_symbol_table() const override { return symtab; }

  /**
   * \brief Getter for member variable \ref NrnStateBlock.solve_statements
   */
  const StatementVector &get_solve_statements() const noexcept {
    return solve_statements;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Set symbol table for the current ast node
   *
   * Top level, block scoped nodes store symbol table in the ast node.
   * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
   * for every node in the ast.
   *
   * \sa nmodl::visitor::SymtabVisitor
   */
  void set_symbol_table(symtab::SymbolTable *newsymtab) override {
    symtab = newsymtab;
  }

  /**
   * \brief Setter for member variable \ref NrnStateBlock.solve_statements
   * (rvalue reference)
   */
  void set_solve_statements(StatementVector &&solve_statements);

  /**
   * \brief Setter for member variable \ref NrnStateBlock.solve_statements
   */
  void set_solve_statements(const StatementVector &solve_statements);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_NRN_STATE_BLOCK_HPP
#ifndef NMODL_AST_EIGEN_NEWTON_SOLVER_BLOCK_HPP
#define NMODL_AST_EIGEN_NEWTON_SOLVER_BLOCK_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represent newton solver solution block based on Eigen
 *
 *
 */
class EigenNewtonSolverBlock : public Block {
private:
  /// number of state vars used in solve
  std::shared_ptr<Integer> n_state_vars;
  /// Statements to be declared in the functor
  std::shared_ptr<StatementBlock> variable_block;
  /// Statement block to be executed before calling newton solver
  std::shared_ptr<StatementBlock> initialize_block;
  /// update X from states
  std::shared_ptr<StatementBlock> setup_x_block;
  /// odes as functor for eigen
  std::shared_ptr<StatementBlock> functor_block;
  /// update back states from X
  std::shared_ptr<StatementBlock> update_states_block;
  /// Statement block to be executed after calling newton solver
  std::shared_ptr<StatementBlock> finalize_block;
  /// token with location information
  std::shared_ptr<ModToken> token;
  /// symbol table for a block
  symtab::SymbolTable *symtab = nullptr;

public:
  /// \name Ctor & dtor
  /// \{

  explicit EigenNewtonSolverBlock(Integer *n_state_vars,
                                  StatementBlock *variable_block,
                                  StatementBlock *initialize_block,
                                  StatementBlock *setup_x_block,
                                  StatementBlock *functor_block,
                                  StatementBlock *update_states_block,
                                  StatementBlock *finalize_block);
  explicit EigenNewtonSolverBlock(
      const std::shared_ptr<Integer> &n_state_vars,
      const std::shared_ptr<StatementBlock> &variable_block,
      const std::shared_ptr<StatementBlock> &initialize_block,
      const std::shared_ptr<StatementBlock> &setup_x_block,
      const std::shared_ptr<StatementBlock> &functor_block,
      const std::shared_ptr<StatementBlock> &update_states_block,
      const std::shared_ptr<StatementBlock> &finalize_block);
  EigenNewtonSolverBlock(const EigenNewtonSolverBlock &obj);

  virtual ~EigenNewtonSolverBlock() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::EigenNewtonSolverBlock
   * \return true as object is of type ast::EigenNewtonSolverBlock
   */
  bool is_eigen_newton_solver_block() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  EigenNewtonSolverBlock *clone() const override {
    return new EigenNewtonSolverBlock(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::EIGEN_NEWTON_SOLVER_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::EIGEN_NEWTON_SOLVER_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "EigenNewtonSolverBlock"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "EigenNewtonSolverBlock";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "EIGEN_NEWTON_SOLVE"
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override {
    return "EIGEN_NEWTON_SOLVE";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<EigenNewtonSolverBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const EigenNewtonSolverBlock>(
        shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return associated symbol table for the current ast node
   *
   * Only certain ast nodes (e.g. inherited from ast::Block) have associated
   * symbol table. These nodes have nmodl::symtab::SymbolTable as member
   * and it can be accessed using this method.
   *
   * \return pointer to the symbol table
   *
   * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
   */
  symtab::SymbolTable *get_symbol_table() const override { return symtab; }

  /**
   * \brief Getter for member variable \ref EigenNewtonSolverBlock.n_state_vars
   */
  const std::shared_ptr<Integer> &get_n_state_vars() const noexcept {
    return n_state_vars;
  }

  /**
   * \brief Getter for member variable \ref
   * EigenNewtonSolverBlock.variable_block
   */
  const std::shared_ptr<StatementBlock> &get_variable_block() const noexcept {
    return variable_block;
  }

  /**
   * \brief Getter for member variable \ref
   * EigenNewtonSolverBlock.initialize_block
   */
  const std::shared_ptr<StatementBlock> &get_initialize_block() const noexcept {
    return initialize_block;
  }

  /**
   * \brief Getter for member variable \ref EigenNewtonSolverBlock.setup_x_block
   */
  const std::shared_ptr<StatementBlock> &get_setup_x_block() const noexcept {
    return setup_x_block;
  }

  /**
   * \brief Getter for member variable \ref EigenNewtonSolverBlock.functor_block
   */
  const std::shared_ptr<StatementBlock> &get_functor_block() const noexcept {
    return functor_block;
  }

  /**
   * \brief Getter for member variable \ref
   * EigenNewtonSolverBlock.update_states_block
   */
  const std::shared_ptr<StatementBlock> &get_update_states_block() const
      noexcept {
    return update_states_block;
  }

  /**
   * \brief Getter for member variable \ref
   * EigenNewtonSolverBlock.finalize_block
   */
  const std::shared_ptr<StatementBlock> &get_finalize_block() const noexcept {
    return finalize_block;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Set symbol table for the current ast node
   *
   * Top level, block scoped nodes store symbol table in the ast node.
   * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
   * for every node in the ast.
   *
   * \sa nmodl::visitor::SymtabVisitor
   */
  void set_symbol_table(symtab::SymbolTable *newsymtab) override {
    symtab = newsymtab;
  }

  /**
   * \brief Setter for member variable \ref EigenNewtonSolverBlock.n_state_vars
   * (rvalue reference)
   */
  void set_n_state_vars(std::shared_ptr<Integer> &&n_state_vars);

  /**
   * \brief Setter for member variable \ref EigenNewtonSolverBlock.n_state_vars
   */
  void set_n_state_vars(const std::shared_ptr<Integer> &n_state_vars);

  /**
   * \brief Setter for member variable \ref
   * EigenNewtonSolverBlock.variable_block (rvalue reference)
   */
  void set_variable_block(std::shared_ptr<StatementBlock> &&variable_block);

  /**
   * \brief Setter for member variable \ref
   * EigenNewtonSolverBlock.variable_block
   */
  void
  set_variable_block(const std::shared_ptr<StatementBlock> &variable_block);

  /**
   * \brief Setter for member variable \ref
   * EigenNewtonSolverBlock.initialize_block (rvalue reference)
   */
  void set_initialize_block(std::shared_ptr<StatementBlock> &&initialize_block);

  /**
   * \brief Setter for member variable \ref
   * EigenNewtonSolverBlock.initialize_block
   */
  void
  set_initialize_block(const std::shared_ptr<StatementBlock> &initialize_block);

  /**
   * \brief Setter for member variable \ref EigenNewtonSolverBlock.setup_x_block
   * (rvalue reference)
   */
  void set_setup_x_block(std::shared_ptr<StatementBlock> &&setup_x_block);

  /**
   * \brief Setter for member variable \ref EigenNewtonSolverBlock.setup_x_block
   */
  void set_setup_x_block(const std::shared_ptr<StatementBlock> &setup_x_block);

  /**
   * \brief Setter for member variable \ref EigenNewtonSolverBlock.functor_block
   * (rvalue reference)
   */
  void set_functor_block(std::shared_ptr<StatementBlock> &&functor_block);

  /**
   * \brief Setter for member variable \ref EigenNewtonSolverBlock.functor_block
   */
  void set_functor_block(const std::shared_ptr<StatementBlock> &functor_block);

  /**
   * \brief Setter for member variable \ref
   * EigenNewtonSolverBlock.update_states_block (rvalue reference)
   */
  void set_update_states_block(
      std::shared_ptr<StatementBlock> &&update_states_block);

  /**
   * \brief Setter for member variable \ref
   * EigenNewtonSolverBlock.update_states_block
   */
  void set_update_states_block(
      const std::shared_ptr<StatementBlock> &update_states_block);

  /**
   * \brief Setter for member variable \ref
   * EigenNewtonSolverBlock.finalize_block (rvalue reference)
   */
  void set_finalize_block(std::shared_ptr<StatementBlock> &&finalize_block);

  /**
   * \brief Setter for member variable \ref
   * EigenNewtonSolverBlock.finalize_block
   */
  void
  set_finalize_block(const std::shared_ptr<StatementBlock> &finalize_block);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_EIGEN_NEWTON_SOLVER_BLOCK_HPP
#ifndef NMODL_AST_EIGEN_LINEAR_SOLVER_BLOCK_HPP
#define NMODL_AST_EIGEN_LINEAR_SOLVER_BLOCK_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represent linear solver solution block based on Eigen
 *
 *
 */
class EigenLinearSolverBlock : public Block {
private:
  /// number of state vars used in solve
  std::shared_ptr<Integer> n_state_vars;
  /// Statements to be declared in the functor
  std::shared_ptr<StatementBlock> variable_block;
  /// Statement block to be executed before calling linear solver
  std::shared_ptr<StatementBlock> initialize_block;
  /// update X from states
  std::shared_ptr<StatementBlock> setup_x_block;
  /// update back states from X
  std::shared_ptr<StatementBlock> update_states_block;
  /// Statement block to be executed after calling linear solver
  std::shared_ptr<StatementBlock> finalize_block;
  /// token with location information
  std::shared_ptr<ModToken> token;
  /// symbol table for a block
  symtab::SymbolTable *symtab = nullptr;

public:
  /// \name Ctor & dtor
  /// \{

  explicit EigenLinearSolverBlock(Integer *n_state_vars,
                                  StatementBlock *variable_block,
                                  StatementBlock *initialize_block,
                                  StatementBlock *setup_x_block,
                                  StatementBlock *update_states_block,
                                  StatementBlock *finalize_block);
  explicit EigenLinearSolverBlock(
      const std::shared_ptr<Integer> &n_state_vars,
      const std::shared_ptr<StatementBlock> &variable_block,
      const std::shared_ptr<StatementBlock> &initialize_block,
      const std::shared_ptr<StatementBlock> &setup_x_block,
      const std::shared_ptr<StatementBlock> &update_states_block,
      const std::shared_ptr<StatementBlock> &finalize_block);
  EigenLinearSolverBlock(const EigenLinearSolverBlock &obj);

  virtual ~EigenLinearSolverBlock() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::EigenLinearSolverBlock
   * \return true as object is of type ast::EigenLinearSolverBlock
   */
  bool is_eigen_linear_solver_block() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  EigenLinearSolverBlock *clone() const override {
    return new EigenLinearSolverBlock(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::EIGEN_LINEAR_SOLVER_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::EIGEN_LINEAR_SOLVER_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "EigenLinearSolverBlock"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "EigenLinearSolverBlock";
  }

  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string i.e. "EIGEN_LINEAR_SOLVE"
   *
   * \sa Ast::get_nmodl_name
   */
  std::string get_nmodl_name() const noexcept override {
    return "EIGEN_LINEAR_SOLVE";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<EigenLinearSolverBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const EigenLinearSolverBlock>(
        shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Return associated symbol table for the current ast node
   *
   * Only certain ast nodes (e.g. inherited from ast::Block) have associated
   * symbol table. These nodes have nmodl::symtab::SymbolTable as member
   * and it can be accessed using this method.
   *
   * \return pointer to the symbol table
   *
   * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
   */
  symtab::SymbolTable *get_symbol_table() const override { return symtab; }

  /**
   * \brief Getter for member variable \ref EigenLinearSolverBlock.n_state_vars
   */
  const std::shared_ptr<Integer> &get_n_state_vars() const noexcept {
    return n_state_vars;
  }

  /**
   * \brief Getter for member variable \ref
   * EigenLinearSolverBlock.variable_block
   */
  const std::shared_ptr<StatementBlock> &get_variable_block() const noexcept {
    return variable_block;
  }

  /**
   * \brief Getter for member variable \ref
   * EigenLinearSolverBlock.initialize_block
   */
  const std::shared_ptr<StatementBlock> &get_initialize_block() const noexcept {
    return initialize_block;
  }

  /**
   * \brief Getter for member variable \ref EigenLinearSolverBlock.setup_x_block
   */
  const std::shared_ptr<StatementBlock> &get_setup_x_block() const noexcept {
    return setup_x_block;
  }

  /**
   * \brief Getter for member variable \ref
   * EigenLinearSolverBlock.update_states_block
   */
  const std::shared_ptr<StatementBlock> &get_update_states_block() const
      noexcept {
    return update_states_block;
  }

  /**
   * \brief Getter for member variable \ref
   * EigenLinearSolverBlock.finalize_block
   */
  const std::shared_ptr<StatementBlock> &get_finalize_block() const noexcept {
    return finalize_block;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Set symbol table for the current ast node
   *
   * Top level, block scoped nodes store symbol table in the ast node.
   * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
   * for every node in the ast.
   *
   * \sa nmodl::visitor::SymtabVisitor
   */
  void set_symbol_table(symtab::SymbolTable *newsymtab) override {
    symtab = newsymtab;
  }

  /**
   * \brief Setter for member variable \ref EigenLinearSolverBlock.n_state_vars
   * (rvalue reference)
   */
  void set_n_state_vars(std::shared_ptr<Integer> &&n_state_vars);

  /**
   * \brief Setter for member variable \ref EigenLinearSolverBlock.n_state_vars
   */
  void set_n_state_vars(const std::shared_ptr<Integer> &n_state_vars);

  /**
   * \brief Setter for member variable \ref
   * EigenLinearSolverBlock.variable_block (rvalue reference)
   */
  void set_variable_block(std::shared_ptr<StatementBlock> &&variable_block);

  /**
   * \brief Setter for member variable \ref
   * EigenLinearSolverBlock.variable_block
   */
  void
  set_variable_block(const std::shared_ptr<StatementBlock> &variable_block);

  /**
   * \brief Setter for member variable \ref
   * EigenLinearSolverBlock.initialize_block (rvalue reference)
   */
  void set_initialize_block(std::shared_ptr<StatementBlock> &&initialize_block);

  /**
   * \brief Setter for member variable \ref
   * EigenLinearSolverBlock.initialize_block
   */
  void
  set_initialize_block(const std::shared_ptr<StatementBlock> &initialize_block);

  /**
   * \brief Setter for member variable \ref EigenLinearSolverBlock.setup_x_block
   * (rvalue reference)
   */
  void set_setup_x_block(std::shared_ptr<StatementBlock> &&setup_x_block);

  /**
   * \brief Setter for member variable \ref EigenLinearSolverBlock.setup_x_block
   */
  void set_setup_x_block(const std::shared_ptr<StatementBlock> &setup_x_block);

  /**
   * \brief Setter for member variable \ref
   * EigenLinearSolverBlock.update_states_block (rvalue reference)
   */
  void set_update_states_block(
      std::shared_ptr<StatementBlock> &&update_states_block);

  /**
   * \brief Setter for member variable \ref
   * EigenLinearSolverBlock.update_states_block
   */
  void set_update_states_block(
      const std::shared_ptr<StatementBlock> &update_states_block);

  /**
   * \brief Setter for member variable \ref
   * EigenLinearSolverBlock.finalize_block (rvalue reference)
   */
  void set_finalize_block(std::shared_ptr<StatementBlock> &&finalize_block);

  /**
   * \brief Setter for member variable \ref
   * EigenLinearSolverBlock.finalize_block
   */
  void
  set_finalize_block(const std::shared_ptr<StatementBlock> &finalize_block);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_EIGEN_LINEAR_SOLVER_BLOCK_HPP
#ifndef NMODL_AST_WRAPPED_EXPRESSION_HPP
#define NMODL_AST_WRAPPED_EXPRESSION_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Wrap any other expression type
 *
 *
 */
class WrappedExpression : public Expression {
private:
  /// Expression that is being wrapped
  std::shared_ptr<Expression> expression;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit WrappedExpression(Expression *expression);
  explicit WrappedExpression(const std::shared_ptr<Expression> &expression);
  WrappedExpression(const WrappedExpression &obj);

  virtual ~WrappedExpression() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::WrappedExpression
   * \return true as object is of type ast::WrappedExpression
   */
  bool is_wrapped_expression() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  WrappedExpression *clone() const override {
    return new WrappedExpression(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::WRAPPED_EXPRESSION
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::WRAPPED_EXPRESSION;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "WrappedExpression"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "WrappedExpression";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<WrappedExpression>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const WrappedExpression>(
        shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref WrappedExpression.expression
   */
  const std::shared_ptr<Expression> &get_expression() const noexcept {
    return expression;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref WrappedExpression.expression (rvalue
   * reference)
   */
  void set_expression(std::shared_ptr<Expression> &&expression);

  /**
   * \brief Setter for member variable \ref WrappedExpression.expression
   */
  void set_expression(const std::shared_ptr<Expression> &expression);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_WRAPPED_EXPRESSION_HPP
#ifndef NMODL_AST_DERIVIMPLICIT_CALLBACK_HPP
#define NMODL_AST_DERIVIMPLICIT_CALLBACK_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represent a callback to NEURON's derivimplicit solver
 *
 *
 */
class DerivimplicitCallback : public Expression {
private:
  /// Block to be solved (typically derivative)
  std::shared_ptr<Block> node_to_solve;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit DerivimplicitCallback(Block *node_to_solve);
  explicit DerivimplicitCallback(const std::shared_ptr<Block> &node_to_solve);
  DerivimplicitCallback(const DerivimplicitCallback &obj);

  virtual ~DerivimplicitCallback() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::DerivimplicitCallback
   * \return true as object is of type ast::DerivimplicitCallback
   */
  bool is_derivimplicit_callback() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  DerivimplicitCallback *clone() const override {
    return new DerivimplicitCallback(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::DERIVIMPLICIT_CALLBACK
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::DERIVIMPLICIT_CALLBACK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "DerivimplicitCallback"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "DerivimplicitCallback";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<DerivimplicitCallback>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const DerivimplicitCallback>(
        shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref DerivimplicitCallback.node_to_solve
   */
  const std::shared_ptr<Block> &get_node_to_solve() const noexcept {
    return node_to_solve;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref DerivimplicitCallback.node_to_solve
   * (rvalue reference)
   */
  void set_node_to_solve(std::shared_ptr<Block> &&node_to_solve);

  /**
   * \brief Setter for member variable \ref DerivimplicitCallback.node_to_solve
   */
  void set_node_to_solve(const std::shared_ptr<Block> &node_to_solve);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_DERIVIMPLICIT_CALLBACK_HPP
#ifndef NMODL_AST_SOLUTION_EXPRESSION_HPP
#define NMODL_AST_SOLUTION_EXPRESSION_HPP

namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represent solution of a block in the AST
 *
 *
 */
class SolutionExpression : public Expression {
private:
  ///
  std::shared_ptr<SolveBlock> solve_block;
  /// Block to be solved (callback node or solution node itself)
  std::shared_ptr<Expression> node_to_solve;
  /// token with location information
  std::shared_ptr<ModToken> token;

public:
  /// \name Ctor & dtor
  /// \{

  explicit SolutionExpression(SolveBlock *solve_block,
                              Expression *node_to_solve);
  explicit SolutionExpression(const std::shared_ptr<SolveBlock> &solve_block,
                              const std::shared_ptr<Expression> &node_to_solve);
  SolutionExpression(const SolutionExpression &obj);

  virtual ~SolutionExpression() = default;

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::SolutionExpression
   * \return true as object is of type ast::SolutionExpression
   */
  bool is_solution_expression() const noexcept override { return true; }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
  SolutionExpression *clone() const override {
    return new SolutionExpression(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::SOLUTION_EXPRESSION
   *
   * \sa Ast::get_node_type_name
   */
  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::SOLUTION_EXPRESSION;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "SolutionExpression"
   *
   * \sa Ast::get_node_name
   */
  std::string get_node_type_name() const noexcept override {
    return "SolutionExpression";
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<SolutionExpression>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const SolutionExpression>(
        shared_from_this());
  }

  /**
   * \brief Return associated token for the current ast node
   *
   * Not all ast nodes have token information. For example,
   * nmodl::visitor::NeuronSolveVisitor can insert new nodes in the ast as a
   * solution of ODEs. In this case, we return nullptr to store in the
   * nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  const ModToken *get_token() const noexcept override { return token.get(); }

  /**
   * \brief Getter for member variable \ref SolutionExpression.solve_block
   */
  const std::shared_ptr<SolveBlock> &get_solve_block() const noexcept {
    return solve_block;
  }

  /**
   * \brief Getter for member variable \ref SolutionExpression.node_to_solve
   */
  const std::shared_ptr<Expression> &get_node_to_solve() const noexcept {
    return node_to_solve;
  }

  /// \}

  /// \name Setters
  /// \{

  /**
   * \brief Set token for the current ast node
   */
  void set_token(const ModToken &tok) {
    token = std::make_shared<ModToken>(tok);
  }

  /**
   * \brief Setter for member variable \ref SolutionExpression.solve_block
   * (rvalue reference)
   */
  void set_solve_block(std::shared_ptr<SolveBlock> &&solve_block);

  /**
   * \brief Setter for member variable \ref SolutionExpression.solve_block
   */
  void set_solve_block(const std::shared_ptr<SolveBlock> &solve_block);

  /**
   * \brief Setter for member variable \ref SolutionExpression.node_to_solve
   * (rvalue reference)
   */
  void set_node_to_solve(std::shared_ptr<Expression> &&node_to_solve);

  /**
   * \brief Setter for member variable \ref SolutionExpression.node_to_solve
   */
  void set_node_to_solve(const std::shared_ptr<Expression> &node_to_solve);

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided
   * visitor
   *
   * Different nodes in the AST have different members (i.e. children). This
   * method recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
  void visit_children(visitor::Visitor &v) override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
  void accept(visitor::Visitor &v) override;

  /// \}

private:
  /**
   * \brief Set this object as parent for all the children
   *
   * This should be called in every object (with children) constructor
   * to set parents. Since it is called only in the constructors it
   * should not be virtual to avoid ambiguities (issue #295).
   */
  void set_parent_in_children();
};

/** @} */ // end of ast_class

} // namespace ast
} // namespace nmodl
#endif // !NMODL_AST_SOLUTION_EXPRESSION_HPP